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 
25 // MARKER(update_precomp.py): autogen include statement, do not remove
26 #include "precompiled_sal.hxx"
27 // autogenerated file with codegen.pl
28 
29 #include <math.h>
30 #include <stdio.h>
31 
32 #include <algorithm> // STL
33 
34 #include "gtest/gtest.h"
35 #include "stringhelper.hxx"
36 #include "valueequal.hxx"
37 
printOUString(::rtl::OUString const & _suStr)38 inline void printOUString( ::rtl::OUString const & _suStr )
39 {
40     rtl::OString aString;
41 
42     printf( "OUString: " );
43     aString = ::rtl::OUStringToOString( _suStr, RTL_TEXTENCODING_ASCII_US );
44     printf( "'%s'\n", aString.getStr( ) );
45 }
46 
47 namespace rtl_OUString
48 {
49 
50     class ctors_rtl_uString : public ::testing::Test
51     {
52     public:
53     };
54 
55     /// test of OUString(rtl_uString*)
TEST_F(ctors_rtl_uString,ctors_001)56     TEST_F(ctors_rtl_uString, ctors_001)
57     {
58         rtl::OUString *pStr = new rtl::OUString( rtl::OUString::createFromAscii("a String") );
59 
60         rtl::OUString aStrToTest(pStr->pData);
61         delete pStr;
62 
63         // maybe here should we do something with current memory
64         char* pBuffer = (char*) malloc(2 * 8);
65         memset(pBuffer, 0, 2 * 8);
66         free(pBuffer);
67 
68         sal_Bool bResult = aStrToTest.equals(rtl::OUString::createFromAscii("a String"));
69         ASSERT_TRUE(bResult == sal_True) << "String must not be empty";
70     }
71 
72 // -----------------------------------------------------------------------------
73 class valueOf : public ::testing::Test
74 {
75 protected:
valueOf_float_test_impl(float _nValue)76     void valueOf_float_test_impl(float _nValue)
77         {
78             rtl::OUString suValue;
79             suValue = rtl::OUString::valueOf( _nValue );
80             rtl::OString sValue;
81             sValue <<= suValue;
82             printf("nFloat := %.9f  sValue := %s\n", _nValue, sValue.getStr());
83 
84             float nValueATOF = static_cast<float>(atof( sValue.getStr() ));
85 
86             bool bEqualResult = is_float_equal(_nValue, nValueATOF);
87             ASSERT_TRUE(bEqualResult == true) << "Values are not equal.";
88         }
89 
valueOf_float_test(float _nValue)90     void valueOf_float_test(float _nValue)
91         {
92             valueOf_float_test_impl(_nValue);
93 
94             // test also the negative part.
95             float nNegativeValue = -_nValue;
96             valueOf_float_test_impl(nNegativeValue);
97         }
98 
99 protected:
100 
valueOf_double_test_impl(double _nValue)101     void valueOf_double_test_impl(double _nValue)
102         {
103             rtl::OUString suValue;
104             suValue = rtl::OUString::valueOf( _nValue );
105             rtl::OString sValue;
106             sValue <<= suValue;
107             printf("nDouble := %.20f  sValue := %s\n", _nValue, sValue.getStr());
108 
109             double nValueATOF = atof( sValue.getStr() );
110 
111             bool bEqualResult = is_double_equal(_nValue, nValueATOF);
112             ASSERT_TRUE(bEqualResult == true) << "Values are not equal.";
113         }
114 
valueOf_double_test(double _nValue)115     void valueOf_double_test(double _nValue)
116         {
117             valueOf_double_test_impl(_nValue);
118 
119             // test also the negative part.
120             double nNegativeValue = -_nValue;
121             valueOf_double_test_impl(nNegativeValue);
122         }
123 }; // class valueOf
124 
TEST_F(valueOf,valueOf_float_test_001)125     TEST_F(valueOf, valueOf_float_test_001)
126     {
127         // this is demonstration code
128         // ASSERT_TRUE(1 == 1) << "a message";
129         float nValue = 3.0f;
130         valueOf_float_test(nValue);
131     }
132 
TEST_F(valueOf,valueOf_float_test_002)133     TEST_F(valueOf, valueOf_float_test_002)
134     {
135         float nValue = 3.5f;
136         valueOf_float_test(nValue);
137     }
138 
TEST_F(valueOf,valueOf_float_test_003)139     TEST_F(valueOf, valueOf_float_test_003)
140     {
141         float nValue = 3.0625f;
142         valueOf_float_test(nValue);
143     }
144 
TEST_F(valueOf,valueOf_float_test_004)145     TEST_F(valueOf, valueOf_float_test_004)
146     {
147         float nValue = 3.502525f;
148         valueOf_float_test(nValue);
149     }
150 
TEST_F(valueOf,valueOf_float_test_005)151     TEST_F(valueOf, valueOf_float_test_005)
152     {
153         float nValue = 3.141592f;
154         valueOf_float_test(nValue);
155     }
156 
TEST_F(valueOf,valueOf_float_test_006)157     TEST_F(valueOf, valueOf_float_test_006)
158     {
159         float nValue = 3.5025255f;
160         valueOf_float_test(nValue);
161     }
162 
TEST_F(valueOf,valueOf_float_test_007)163     TEST_F(valueOf, valueOf_float_test_007)
164     {
165         float nValue = 3.0039062f;
166         valueOf_float_test(nValue);
167     }
168 
169     // valueOf double
TEST_F(valueOf,valueOf_double_test_001)170     TEST_F(valueOf, valueOf_double_test_001)
171     {
172         double nValue = 3.0;
173         valueOf_double_test(nValue);
174     }
TEST_F(valueOf,valueOf_double_test_002)175     TEST_F(valueOf, valueOf_double_test_002)
176     {
177         double nValue = 3.5;
178         valueOf_double_test(nValue);
179     }
TEST_F(valueOf,valueOf_double_test_003)180     TEST_F(valueOf, valueOf_double_test_003)
181     {
182         double nValue = 3.0625;
183         valueOf_double_test(nValue);
184     }
TEST_F(valueOf,valueOf_double_test_004)185     TEST_F(valueOf, valueOf_double_test_004)
186     {
187         double nValue = 3.1415926535;
188         valueOf_double_test(nValue);
189     }
TEST_F(valueOf,valueOf_double_test_005)190     TEST_F(valueOf, valueOf_double_test_005)
191     {
192         double nValue = 3.141592653589793;
193         valueOf_double_test(nValue);
194     }
TEST_F(valueOf,valueOf_double_test_006)195     TEST_F(valueOf, valueOf_double_test_006)
196     {
197         double nValue = 3.1415926535897932;
198         valueOf_double_test(nValue);
199     }
TEST_F(valueOf,valueOf_double_test_007)200     TEST_F(valueOf, valueOf_double_test_007)
201     {
202         double nValue = 3.14159265358979323;
203         valueOf_double_test(nValue);
204     }
TEST_F(valueOf,valueOf_double_test_008)205     TEST_F(valueOf, valueOf_double_test_008)
206     {
207         double nValue = 3.141592653589793238462643;
208         valueOf_double_test(nValue);
209     }
210 
211 //------------------------------------------------------------------------
212 // testing the method toDouble()
213 //------------------------------------------------------------------------
214 template<class T>
checkPrecisionSize()215 sal_Int16 SAL_CALL checkPrecisionSize()
216 {
217 	// sal_Int16 nSize = sizeof(T);
218 	volatile T nCalcValue = 1.0;
219 
220 
221 	// (i + 1) is the current precision
222     // numerical series
223     // 1.1
224     // 10.1
225     // 100.1
226     // ...
227     // 1000...0.1
228 
229 	sal_Int16 i = 0;
230 	for (i=0;i<50;i++)
231 	{
232 		nCalcValue *= 10;
233 		volatile T nValue = nCalcValue + static_cast<T>(0.1);
234 		volatile T dSub = nValue - nCalcValue;
235 		// ----- 0.11 ---- 0.1 ---- 0.09 -----
236 		if (0.11 > dSub && dSub < 0.09)
237 		{
238 			// due to the fact, that the value is break down we sub 1 from the precision value
239 			// but to suppress this, we start at zero, precision is i+1 till here --i;
240 			break;
241 		}
242 	}
243 
244 	sal_Int16 j= 0;
245 	nCalcValue = 1.0;
246 
247     // numerical series
248     // 1.1
249     // 1.01
250     // 1.001
251     // ...
252     // 1.000...001
253 
254 	for (j=0;j<50;j++)
255 	{
256 		nCalcValue /= 10;
257 		volatile T nValue = nCalcValue + static_cast<T>(1.0);
258 		volatile T dSub = nValue - static_cast<T>(1.0);
259 		// ---- 0.02 ----- 0.01 ---- 0 --- -0.99 ---- -0.98 ----
260 		// volatile T dSubAbsolut = fabs(dSub);
261 		// ---- 0.02 ----- 0.01 ---- 0 (cut)
262 		if ( dSub == 0)
263 			break;
264 	}
265 	if (i != j)
266 	{
267             // hmmm....
268             // imho i +- 1 == j is a good value
269             int n = i - j;
270             if (n < 0) n = -n;
271             if (n <= 1)
272             {
273                 return std::min(i,j);
274             }
275             else
276             {
277                 printf("warning: presision differs more than 1!\n");
278             }
279         }
280 
281 	return i;
282 }
283 
284 // -----------------------------------------------------------------------------
285 
286     class testPrecision
287     {
288     public:
testPrecision()289         testPrecision()
290             {
291                 sal_Int16 nPrecision;
292                 nPrecision = checkPrecisionSize<float>();
293                 printf("precision of float: %d sizeof()=%lu \n", nPrecision, sizeof(float));
294 
295                 nPrecision = checkPrecisionSize<double>();
296                 printf("precision of double: %d sizeof()=%lu \n", nPrecision, sizeof(double));
297 
298                 nPrecision = checkPrecisionSize<long double>();
299                 printf("precision of long double: %d sizeof()=%lu \n", nPrecision, sizeof(long double));
300 
301             }
302 
303     };
304 
305     class toInt: public ::testing::Test {
306     public:
307     };
308 
TEST_F(toInt,test)309     TEST_F(toInt, test) {
310         ASSERT_EQ(
311             static_cast< sal_Int32 >(-0x76543210),
312             (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-76543210")).
313             toInt32(16)));
314         ASSERT_EQ(
315             static_cast< sal_Int32 >(0xFEDCBA98),
316             (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("+FEDCBA98")).
317             toInt32(16)));
318         ASSERT_EQ(
319             static_cast< sal_Int64 >(-SAL_CONST_INT64(0x76543210FEDCBA98)),
320             (rtl::OUString(
321             RTL_CONSTASCII_USTRINGPARAM("-76543210FEDCBA98")).
322             toInt64(16)));
323         ASSERT_EQ(
324             static_cast< sal_Int64 >(SAL_CONST_INT64(0xFEDCBA9876543210)),
325             (rtl::OUString(
326             RTL_CONSTASCII_USTRINGPARAM("+FEDCBA9876543210")).
327             toInt64(16)));
328     }
329 
330 // -----------------------------------------------------------------------------
331 // - toDouble (tests)
332 // -----------------------------------------------------------------------------
333     class toDouble : public ::testing::Test
334     {
335     public:
toDouble_test_impl(rtl::OString const & _sValue)336         void toDouble_test_impl(rtl::OString const& _sValue)
337             {
338             	//printf("the original str is %s\n", _sValue.getStr());
339                 double nValueATOF = atof( _sValue.getStr() );
340 		//printf("original data is %e\n", nValueATOF);
341                 rtl::OUString suValue = rtl::OUString::createFromAscii( _sValue.getStr() );
342                 double nValueToDouble = suValue.toDouble();
343                 //printf("result data is %e\n", nValueToDouble);
344 
345                 bool bEqualResult = is_double_equal(nValueToDouble, nValueATOF);
346                 ASSERT_TRUE(bEqualResult == true) << "Values are not equal.";
347             }
348 
toDouble_test(rtl::OString const & _sValue)349         void toDouble_test(rtl::OString const& _sValue)
350             {
351                 toDouble_test_impl(_sValue);
352 
353                 // test also the negativ part.
354                 rtl::OString sNegativValue("-");
355                 sNegativValue += _sValue;
356                 toDouble_test_impl(sNegativValue);
357             }
358     }; // class toDouble
359 
TEST_F(toDouble,toDouble_selftest)360     TEST_F(toDouble, toDouble_selftest)
361     {
362         printf("Start selftest:\n");
363         ASSERT_TRUE (is_double_equal(1.0, 1.01) == false);
364         ASSERT_TRUE (is_double_equal(1.0, 1.001) == false);
365         ASSERT_TRUE (is_double_equal(1.0, 1.0001) == false);
366         ASSERT_TRUE (is_double_equal(1.0, 1.00001) == false);
367         ASSERT_TRUE (is_double_equal(1.0, 1.000001) == false);
368         ASSERT_TRUE (is_double_equal(1.0, 1.0000001) == false);
369         ASSERT_TRUE (is_double_equal(1.0, 1.00000001) == false);
370         ASSERT_TRUE (is_double_equal(1.0, 1.000000001) == false);
371         ASSERT_TRUE (is_double_equal(1.0, 1.0000000001) == false);
372         ASSERT_TRUE (is_double_equal(1.0, 1.00000000001) == false);
373         ASSERT_TRUE (is_double_equal(1.0, 1.000000000001) == false);
374         ASSERT_TRUE (is_double_equal(1.0, 1.0000000000001) == false);
375         // we check til 15 values after comma
376         ASSERT_TRUE (is_double_equal(1.0, 1.00000000000001) == true);
377         ASSERT_TRUE (is_double_equal(1.0, 1.000000000000001) == true);
378         ASSERT_TRUE (is_double_equal(1.0, 1.0000000000000001) == true);
379         printf("Selftest done.\n");
380     }
381 
TEST_F(toDouble,toDouble_test_3)382     TEST_F(toDouble, toDouble_test_3)
383     {
384         rtl::OString sValue("3");
385         toDouble_test(sValue);
386     }
TEST_F(toDouble,toDouble_test_3_5)387     TEST_F(toDouble, toDouble_test_3_5)
388     {
389         rtl::OString sValue("3.5");
390         toDouble_test(sValue);
391     }
TEST_F(toDouble,toDouble_test_3_0625)392     TEST_F(toDouble, toDouble_test_3_0625)
393     {
394         rtl::OString sValue("3.0625");
395         toDouble_test(sValue);
396     }
TEST_F(toDouble,toDouble_test_pi)397     TEST_F(toDouble, toDouble_test_pi)
398     {
399         // value from http://www.angio.net/pi/digits/50.txt
400         rtl::OString sValue("3.141592653589793238462643383279502884197169399375");
401         toDouble_test(sValue);
402     }
403 
TEST_F(toDouble,toDouble_test_1)404     TEST_F(toDouble, toDouble_test_1)
405     {
406         rtl::OString sValue("1");
407         toDouble_test(sValue);
408     }
TEST_F(toDouble,toDouble_test_10)409     TEST_F(toDouble, toDouble_test_10)
410     {
411         rtl::OString sValue("10");
412         toDouble_test(sValue);
413     }
TEST_F(toDouble,toDouble_test_100)414     TEST_F(toDouble, toDouble_test_100)
415     {
416         rtl::OString sValue("100");
417         toDouble_test(sValue);
418     }
TEST_F(toDouble,toDouble_test_1000)419     TEST_F(toDouble, toDouble_test_1000)
420     {
421         rtl::OString sValue("1000");
422         toDouble_test(sValue);
423     }
TEST_F(toDouble,toDouble_test_10000)424     TEST_F(toDouble, toDouble_test_10000)
425     {
426         rtl::OString sValue("10000");
427         toDouble_test(sValue);
428     }
TEST_F(toDouble,toDouble_test_1e99)429     TEST_F(toDouble, toDouble_test_1e99)
430     {
431         rtl::OString sValue("1e99");
432         toDouble_test(sValue);
433     }
TEST_F(toDouble,toDouble_test_1e_n99)434     TEST_F(toDouble, toDouble_test_1e_n99)
435     {
436         rtl::OString sValue("1e-99");
437         toDouble_test(sValue);
438     }
TEST_F(toDouble,toDouble_test_1e308)439     TEST_F(toDouble, toDouble_test_1e308)
440     {
441         rtl::OString sValue("1e308");
442         toDouble_test(sValue);
443     }
444 
445 // -----------------------------------------------------------------------------
446 // - toFloat (tests)
447 // -----------------------------------------------------------------------------
448     class toFloat : public ::testing::Test
449     {
450     public:
toFloat_test_impl(rtl::OString const & _sValue)451         void toFloat_test_impl(rtl::OString const& _sValue)
452             {
453             	//printf("the original str is %s\n", _sValue.getStr());
454                 float nValueATOF = static_cast<float>(atof( _sValue.getStr() ));
455 		//printf("the original str is %.10f\n", nValueATOF);
456                 rtl::OUString suValue = rtl::OUString::createFromAscii( _sValue.getStr() );
457                 float nValueToFloat = suValue.toFloat();
458                 //printf("the result str is %.10f\n", nValueToFloat);
459 
460                 bool bEqualResult = is_float_equal(nValueToFloat, nValueATOF);
461                 ASSERT_TRUE(bEqualResult == true) << "Values are not equal.";
462             }
463 
toFloat_test(rtl::OString const & _sValue)464         void toFloat_test(rtl::OString const& _sValue)
465             {
466                 toFloat_test_impl(_sValue);
467 
468                 // test also the negativ part.
469                 rtl::OString sNegativValue("-");
470                 sNegativValue += _sValue;
471                 toFloat_test_impl(sNegativValue);
472             }
473     }; // class toFloat
474 
TEST_F(toFloat,toFloat_selftest)475     TEST_F(toFloat, toFloat_selftest)
476     {
477         printf("Start selftest:\n");
478         ASSERT_TRUE (is_float_equal(1.0f, 1.01f) == false);
479         ASSERT_TRUE (is_float_equal(1.0f, 1.001f) == false);
480         ASSERT_TRUE (is_float_equal(1.0f, 1.0001f) == false);
481         ASSERT_TRUE (is_float_equal(1.0f, 1.00001f) == false);
482         ASSERT_TRUE (is_float_equal(1.0f, 1.000002f) == false);
483         ASSERT_TRUE (is_float_equal(1.0f, 1.0000001f) == true);
484         ASSERT_TRUE (is_float_equal(1.0f, 1.00000001f) == true);
485         ASSERT_TRUE (is_float_equal(1.0f, 1.000000001f) == true);
486 
487         printf("Selftest done.\n");
488     }
489 
TEST_F(toFloat,toFloat_test_3)490     TEST_F(toFloat, toFloat_test_3)
491     {
492         rtl::OString sValue("3");
493         toFloat_test(sValue);
494     }
TEST_F(toFloat,toFloat_test_3_5)495     TEST_F(toFloat, toFloat_test_3_5)
496     {
497         rtl::OString sValue("3.5");
498         toFloat_test(sValue);
499     }
TEST_F(toFloat,toFloat_test_3_0625)500     TEST_F(toFloat, toFloat_test_3_0625)
501     {
502         rtl::OString sValue("3.0625");
503         toFloat_test(sValue);
504     }
TEST_F(toFloat,toFloat_test_3_0625_e)505     TEST_F(toFloat, toFloat_test_3_0625_e)
506     {
507         rtl::OString sValue("3.0625e-4");
508         toFloat_test(sValue);
509     }
TEST_F(toFloat,toFloat_test_pi)510     TEST_F(toFloat, toFloat_test_pi)
511     {
512         // value from http://www.angio.net/pi/digits/50.txt
513         rtl::OString sValue("3.141592653589793238462643383279502884197169399375");
514         toFloat_test(sValue);
515     }
516 
TEST_F(toFloat,toFloat_test_1)517     TEST_F(toFloat, toFloat_test_1)
518     {
519         rtl::OString sValue("1");
520         toFloat_test(sValue);
521     }
TEST_F(toFloat,toFloat_test_10)522     TEST_F(toFloat, toFloat_test_10)
523     {
524         rtl::OString sValue("10");
525         toFloat_test(sValue);
526     }
TEST_F(toFloat,toFloat_test_100)527     TEST_F(toFloat, toFloat_test_100)
528     {
529         rtl::OString sValue("100");
530         toFloat_test(sValue);
531     }
TEST_F(toFloat,toFloat_test_1000)532     TEST_F(toFloat, toFloat_test_1000)
533     {
534         rtl::OString sValue("1000");
535         toFloat_test(sValue);
536     }
TEST_F(toFloat,toFloat_test_10000)537     TEST_F(toFloat, toFloat_test_10000)
538     {
539         rtl::OString sValue("10000");
540         toFloat_test(sValue);
541     }
TEST_F(toFloat,toFloat_test_mix)542     TEST_F(toFloat, toFloat_test_mix)
543     {
544         rtl::OString sValue("456789321455.123456789012");
545         toFloat_test(sValue);
546     }
TEST_F(toFloat,toFloat_test_1e99)547     TEST_F(toFloat, toFloat_test_1e99)
548     {
549         rtl::OString sValue("1e99");
550         toFloat_test(sValue);
551     }
TEST_F(toFloat,toFloat_test_1e_n99)552     TEST_F(toFloat, toFloat_test_1e_n99)
553     {
554         rtl::OString sValue("1e-9");
555         toFloat_test(sValue);
556     }
TEST_F(toFloat,toFloat_test_1e308)557     TEST_F(toFloat, toFloat_test_1e308)
558     {
559         rtl::OString sValue("1e308");
560         toFloat_test(sValue);
561     }
562 
563 // -----------------------------------------------------------------------------
564 // - lastIndexOf (tests)
565 // -----------------------------------------------------------------------------
566 class lastIndexOf : public ::testing::Test
567 {
568 public:
lastIndexOf_oustring(rtl::OUString const & _suStr,rtl::OUString const & _suSearchStr,sal_Int32 _nExpectedResultPos)569     void lastIndexOf_oustring(rtl::OUString const& _suStr, rtl::OUString const& _suSearchStr, sal_Int32 _nExpectedResultPos)
570         {
571             // Algorithm
572             // search the string _suSearchStr (rtl::OUString) in the string _suStr.
573             // check if the _nExpectedResultPos occurs.
574 
575             sal_Int32 nPos = _suStr.lastIndexOf(_suSearchStr);
576             ASSERT_TRUE(nPos == _nExpectedResultPos) << "expected position is wrong";
577         }
578 
lastIndexOf_salunicode(rtl::OUString const & _suStr,sal_Unicode _cuSearchChar,sal_Int32 _nExpectedResultPos)579     void lastIndexOf_salunicode(rtl::OUString const& _suStr, sal_Unicode _cuSearchChar, sal_Int32 _nExpectedResultPos)
580         {
581             // Algorithm
582             // search the unicode char _suSearchChar (sal_Unicode) in the string _suStr.
583             // check if the _nExpectedResultPos occurs.
584 
585             sal_Int32 nPos = _suStr.lastIndexOf(_cuSearchChar);
586             ASSERT_TRUE(nPos == _nExpectedResultPos) << "expected position is wrong";
587         }
588 
lastIndexOf_oustring_offset(rtl::OUString const & _suStr,rtl::OUString const & _suSearchStr,sal_Int32 _nExpectedResultPos,sal_Int32 _nStartOffset)589     void lastIndexOf_oustring_offset(rtl::OUString const& _suStr, rtl::OUString const& _suSearchStr, sal_Int32 _nExpectedResultPos, sal_Int32 _nStartOffset)
590         {
591             sal_Int32 nPos = _suStr.lastIndexOf(_suSearchStr, _nStartOffset);
592             ASSERT_TRUE(nPos == _nExpectedResultPos) << "expected position is wrong";
593         }
594 
lastIndexOf_salunicode_offset(rtl::OUString const & _suStr,sal_Unicode _cuSearchChar,sal_Int32 _nExpectedResultPos,sal_Int32 _nStartOffset)595     void lastIndexOf_salunicode_offset(rtl::OUString const& _suStr, sal_Unicode _cuSearchChar, sal_Int32 _nExpectedResultPos, sal_Int32 _nStartOffset)
596         {
597             sal_Int32 nPos = _suStr.lastIndexOf(_cuSearchChar, _nStartOffset);
598             ASSERT_TRUE(nPos == _nExpectedResultPos) << "expected position is wrong";
599         }
600 }; // class lastIndexOf
601 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_offset_001)602     TEST_F(lastIndexOf, lastIndexOf_test_oustring_offset_001)
603     {
604         // search for sun, start at the end, found (pos==0)
605         rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system");
606         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
607         lastIndexOf_oustring_offset(aStr, aSearchStr, 0, aStr.getLength());
608     }
609 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_offset_002)610     TEST_F(lastIndexOf, lastIndexOf_test_oustring_offset_002)
611     {
612         // search for sun, start at pos = 3, found (pos==0)
613         rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system");
614         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
615         lastIndexOf_oustring_offset(aStr, aSearchStr, 0, 3);
616     }
617 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_offset_003)618     TEST_F(lastIndexOf, lastIndexOf_test_oustring_offset_003)
619     {
620         // search for sun, start at pos = 2, found (pos==-1)
621         rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system");
622         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
623         lastIndexOf_oustring_offset(aStr, aSearchStr, -1, 2);
624     }
625 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_offset_004)626     TEST_F(lastIndexOf, lastIndexOf_test_oustring_offset_004)
627     {
628         // search for sun, start at the end, found (pos==0)
629         rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system");
630         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
631         lastIndexOf_oustring_offset(aStr, aSearchStr, -1, -1);
632     }
633 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_001)634     TEST_F(lastIndexOf, lastIndexOf_test_oustring_001)
635     {
636         // search for sun, found (pos==0)
637         rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system");
638         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
639         lastIndexOf_oustring(aStr, aSearchStr, 0);
640     }
641 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_002)642     TEST_F(lastIndexOf, lastIndexOf_test_oustring_002)
643     {
644         // search for sun, found (pos==4)
645         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun java system");
646         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
647         lastIndexOf_oustring(aStr, aSearchStr, 4);
648     }
649 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_003)650     TEST_F(lastIndexOf, lastIndexOf_test_oustring_003)
651     {
652         // search for sun, found (pos==8)
653         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system");
654         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
655         lastIndexOf_oustring(aStr, aSearchStr, 8);
656     }
657 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_004)658     TEST_F(lastIndexOf, lastIndexOf_test_oustring_004)
659     {
660         // search for sun, found (pos==8)
661         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun");
662         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
663         lastIndexOf_oustring(aStr, aSearchStr, 8);
664     }
665 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_005)666     TEST_F(lastIndexOf, lastIndexOf_test_oustring_005)
667     {
668         // search for sun, found (pos==4)
669         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun su");
670         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
671         lastIndexOf_oustring(aStr, aSearchStr, 4);
672     }
673 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_006)674     TEST_F(lastIndexOf, lastIndexOf_test_oustring_006)
675     {
676         // search for sun, found (pos==-1)
677         rtl::OUString aStr = rtl::OUString::createFromAscii("the su su");
678         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun");
679         lastIndexOf_oustring(aStr, aSearchStr, -1);
680     }
681 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_007)682     TEST_F(lastIndexOf, lastIndexOf_test_oustring_007)
683     {
684         // search for earth, not found (-1)
685         rtl::OUString aStr = rtl::OUString::createFromAscii("the su su");
686         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("earth");
687         lastIndexOf_oustring(aStr, aSearchStr, -1);
688     }
689 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_008)690     TEST_F(lastIndexOf, lastIndexOf_test_oustring_008)
691     {
692         // search for earth, not found (-1)
693         rtl::OUString aStr = rtl::OUString();
694         rtl::OUString aSearchStr = rtl::OUString::createFromAscii("earth");
695         lastIndexOf_oustring(aStr, aSearchStr, -1);
696     }
697 
TEST_F(lastIndexOf,lastIndexOf_test_oustring_009)698     TEST_F(lastIndexOf, lastIndexOf_test_oustring_009)
699     {
700         // search for earth, not found (-1)
701         rtl::OUString aStr = rtl::OUString();
702         rtl::OUString aSearchStr = rtl::OUString();
703         lastIndexOf_oustring(aStr, aSearchStr, -1);
704 
705     }
706 
TEST_F(lastIndexOf,lastIndexOf_test_salunicode_001)707     TEST_F(lastIndexOf, lastIndexOf_test_salunicode_001)
708     {
709         // search for 's', found (19)
710         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system");
711         sal_Unicode suChar = L's';
712         lastIndexOf_salunicode(aStr, suChar, 19);
713     }
714 
TEST_F(lastIndexOf,lastIndexOf_test_salunicode_002)715     TEST_F(lastIndexOf, lastIndexOf_test_salunicode_002)
716     {
717         // search for 'x', not found (-1)
718         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system");
719         sal_Unicode suChar = L'x';
720         lastIndexOf_salunicode(aStr, suChar, -1);
721     }
722 
TEST_F(lastIndexOf,lastIndexOf_test_salunicode_offset_001)723     TEST_F(lastIndexOf, lastIndexOf_test_salunicode_offset_001)
724     {
725         // search for 's', start from pos last char, found (19)
726         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system");
727         sal_Unicode cuChar = L's';
728         lastIndexOf_salunicode_offset(aStr, cuChar, 19, aStr.getLength());
729     }
TEST_F(lastIndexOf,lastIndexOf_test_salunicode_offset_002)730     TEST_F(lastIndexOf, lastIndexOf_test_salunicode_offset_002)
731     {
732         // search for 's', start pos is last occur from search behind, found (17)
733         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system");
734         sal_Unicode cuChar = L's';
735         lastIndexOf_salunicode_offset(aStr, cuChar, 17, 19);
736     }
TEST_F(lastIndexOf,lastIndexOf_test_salunicode_offset_003)737     TEST_F(lastIndexOf, lastIndexOf_test_salunicode_offset_003)
738     {
739         // search for 't', start pos is 1, found (0)
740         rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system");
741         sal_Unicode cuChar = L't';
742         lastIndexOf_salunicode_offset(aStr, cuChar, 0, 1);
743     }
744 
745 // -----------------------------------------------------------------------------
746 // - getToken (tests)
747 // -----------------------------------------------------------------------------
748 class getToken : public ::testing::Test
749 {
750 public:
751 }; // class getToken
752 
TEST_F(getToken,getToken_000)753     TEST_F(getToken, getToken_000)
754     {
755         rtl::OUString suTokenStr;
756 
757         sal_Int32 nIndex = 0;
758         do
759         {
760             rtl::OUString suToken = suTokenStr.getToken( 0, ';', nIndex );
761         }
762         while ( nIndex >= 0 );
763         printf("Index %d\n", nIndex);
764         // should not GPF
765     }
766 
TEST_F(getToken,getToken_001)767     TEST_F(getToken, getToken_001)
768     {
769         rtl::OUString suTokenStr = rtl::OUString::createFromAscii("a;b");
770 
771         sal_Int32 nIndex = 0;
772 
773         rtl::OUString suToken = suTokenStr.getToken( 0, ';', nIndex );
774         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("a")) == sal_True) << "Token should be a 'a'";
775 
776         /* rtl::OUString */ suToken = suTokenStr.getToken( 0, ';', nIndex );
777         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("b")) == sal_True) << "Token should be a 'b'";
778         ASSERT_TRUE(nIndex == -1) << "index should be negative";
779     }
780 
TEST_F(getToken,getToken_002)781     TEST_F(getToken, getToken_002)
782     {
783         rtl::OUString suTokenStr = rtl::OUString::createFromAscii("a;b.c");
784 
785         sal_Int32 nIndex = 0;
786 
787         rtl::OUString suToken = suTokenStr.getToken( 0, ';', nIndex );
788         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("a")) == sal_True) << "Token should be a 'a'";
789 
790         /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex );
791         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("b")) == sal_True) << "Token should be a 'b'";
792 
793         /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex );
794         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("c")) == sal_True) << "Token should be a 'c'";
795         ASSERT_TRUE(nIndex == -1) << "index should be negative";
796     }
797 
TEST_F(getToken,getToken_003)798     TEST_F(getToken, getToken_003)
799     {
800         rtl::OUString suTokenStr = rtl::OUString::createFromAscii("a;;b");
801 
802         sal_Int32 nIndex = 0;
803 
804         rtl::OUString suToken = suTokenStr.getToken( 0, ';', nIndex );
805         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("a")) == sal_True) << "Token should be a 'a'";
806 
807         /* rtl::OUString */ suToken = suTokenStr.getToken( 0, ';', nIndex );
808         ASSERT_TRUE(suToken.getLength() == 0) << "Token should be empty";
809 
810         /* rtl::OUString */ suToken = suTokenStr.getToken( 0, ';', nIndex );
811         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("b")) == sal_True) << "Token should be a 'b'";
812         ASSERT_TRUE(nIndex == -1) << "index should be negative";
813     }
814 
TEST_F(getToken,getToken_004)815     TEST_F(getToken, getToken_004)
816     {
817         rtl::OUString suTokenStr = rtl::OUString::createFromAscii("longer.then.ever.");
818 
819         sal_Int32 nIndex = 0;
820 
821         rtl::OUString suToken = suTokenStr.getToken( 0, '.', nIndex );
822         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("longer")) == sal_True) << "Token should be 'longer'";
823 
824         /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex );
825         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("then")) == sal_True) << "Token should be 'then'";
826 
827         /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex );
828         ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("ever")) == sal_True) << "Token should be 'ever'";
829 
830         /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex );
831         ASSERT_TRUE(suToken.getLength() == 0) << "Token should be empty";
832 
833         ASSERT_TRUE(nIndex == -1) << "index should be negative";
834     }
835 
TEST_F(getToken,getToken_005)836     TEST_F(getToken, getToken_005) {
837         rtl::OUString ab(RTL_CONSTASCII_USTRINGPARAM("ab"));
838         sal_Int32 n = 0;
839         ASSERT_TRUE(ab.getToken(0, '-', n) == ab) << "token should be 'ab'";
840         ASSERT_TRUE(n == -1) << "n should be -1";
841         ASSERT_TRUE(ab.getToken(0, '-', n).getLength() == 0) << "token should be empty";
842     }
843 
844 class convertToString: public ::testing::Test {
845 public:
846 };
847 
TEST_F(convertToString,test)848 TEST_F(convertToString, test) {
849     static sal_Unicode const utf16[] = { 0x0041, 0x00E4, 0x0061 };
850     rtl::OString s;
851     ASSERT_TRUE(
852         rtl::OUString(utf16, sizeof utf16 / sizeof utf16[0]).convertToString(
853             &s, RTL_TEXTENCODING_UTF7,
854             (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
855              RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR)));
856     ASSERT_EQ(
857         rtl::OString(RTL_CONSTASCII_STRINGPARAM("A+AOQ-a")), s);
858 }
859 
860 // -----------------------------------------------------------------------------
861 // - string construction & interning (tests)
862 // -----------------------------------------------------------------------------
863 class construction : public ::testing::Test
864 {
865 public:
866 };
867 
TEST_F(construction,construct)868     TEST_F(construction, construct)
869     {
870 #ifdef RTL_INLINE_STRINGS
871         ::rtl::OUString aFoo( RTL_CONSTASCII_USTRINGPARAM("foo") );
872         ASSERT_TRUE(aFoo[0] == 'f') << "string contents";
873         ASSERT_TRUE(aFoo[1] == 'o') << "string contents";
874         ASSERT_TRUE(aFoo[2] == 'o') << "string contents";
875         ASSERT_TRUE(aFoo.getLength() == 3) << "string length";
876 
877         ::rtl::OUString aBaa( RTL_CONSTASCII_USTRINGPARAM("this is a very long string with a lot of long things inside it and it goes on and on and on forever etc.") );
878         ASSERT_TRUE(aBaa.getLength() == 104) << "string length";
879         // Dig at the internals ... FIXME: should we have the bit-flag defines public ?
880         ASSERT_TRUE((aBaa.pData->refCount & 1<<30) != 0) << "string static flags";
881 #endif
882     }
883 
TEST_F(construction,intern)884     TEST_F(construction, intern)
885     {
886         // The empty string is 'static' a special case ...
887         rtl::OUString aEmpty = rtl::OUString().intern();
888         rtl::OUString aEmpty2 = rtl::OUString::intern( RTL_CONSTASCII_USTRINGPARAM( "" ) );
889 
890         ::rtl::OUString aFoo( RTL_CONSTASCII_USTRINGPARAM("foo") );
891         ::rtl::OUString aFooIntern = aFoo.intern();
892         ASSERT_TRUE(aFooIntern.equalsAscii("foo")) << "string contents";
893         ASSERT_TRUE(aFooIntern.getLength() == 3) << "string length";
894         // We have to dup due to no atomic 'intern' bit-set operation
895         ASSERT_TRUE(aFoo.pData != aFooIntern.pData) << "intern dups";
896 
897         // Test interning lots of things
898         int i;
899         static const int nSequence = 4096;
900         rtl::OUString *pStrs;
901         sal_uIntPtr   *pValues;
902 
903         pStrs = new rtl::OUString[nSequence];
904         pValues = new sal_uIntPtr[nSequence];
905         for (i = 0; i < nSequence; i++)
906         {
907             pStrs[i] = rtl::OUString::valueOf( sqrt( static_cast<double>(i) ) ).intern();
908             pValues[i] = reinterpret_cast<sal_uIntPtr>( pStrs[i].pData );
909         }
910         for (i = 0; i < nSequence; i++)
911         {
912             rtl::OUString aNew = rtl::OUString::valueOf( sqrt( static_cast<double>(i) ) ).intern();
913             ASSERT_TRUE(aNew.pData == pStrs[i].pData) << "double intern failed";
914         }
915 
916         // Free strings to check for leaks
917         for (i = 0; i < nSequence; i++)
918         {
919             // Overwrite - hopefully this re-uses the memory
920             pStrs[i] = rtl::OUString();
921             pStrs[i] = rtl::OUString::valueOf( sqrt( static_cast<double>(i) ) );
922         }
923 
924         for (i = 0; i < nSequence; i++)
925         {
926             rtl::OUString aIntern;
927             sal_uIntPtr nValue;
928             aIntern = rtl::OUString::valueOf( sqrt( static_cast<double>(i) ) ).intern();
929 
930             nValue = reinterpret_cast<sal_uIntPtr>( aIntern.pData );
931             // This may not be 100% reliable: memory may
932             // have been re-used, but it's worth checking.
933             ASSERT_TRUE(nValue != pValues[i]) << "intern leaking";
934         }
935         delete [] pValues;
936         delete [] pStrs;
937     }
938 
939 class indexOfAscii: public ::testing::Test {
940 public:
941 };
942 
TEST_F(indexOfAscii,test)943 TEST_F(indexOfAscii, test) {
944     ASSERT_EQ(
945         sal_Int32(-1),
946         rtl::OUString().indexOfAsciiL(RTL_CONSTASCII_STRINGPARAM("")));
947     ASSERT_EQ(
948         sal_Int32(-1),
949         rtl::OUString().lastIndexOfAsciiL(RTL_CONSTASCII_STRINGPARAM("")));
950     ASSERT_EQ(
951         sal_Int32(0),
952         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foo")).indexOfAsciiL(
953             RTL_CONSTASCII_STRINGPARAM("foo")));
954     ASSERT_EQ(
955         sal_Int32(0),
956         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foo")).lastIndexOfAsciiL(
957             RTL_CONSTASCII_STRINGPARAM("foo")));
958     ASSERT_EQ(
959         sal_Int32(2),
960         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("fofoobar")).indexOfAsciiL(
961             RTL_CONSTASCII_STRINGPARAM("foo")));
962     ASSERT_EQ(
963         sal_Int32(3),
964         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foofoofob")).
965         lastIndexOfAsciiL(RTL_CONSTASCII_STRINGPARAM("foo")));
966     ASSERT_EQ(
967         sal_Int32(3),
968         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foofoobar")).indexOfAsciiL(
969             RTL_CONSTASCII_STRINGPARAM("foo"), 1));
970 }
971 
972 class endsWith: public ::testing::Test {
973 public:
974 };
975 
TEST_F(endsWith,test)976 TEST_F(endsWith, test) {
977     ASSERT_EQ(
978         true,
979         rtl::OUString().endsWithAsciiL(RTL_CONSTASCII_STRINGPARAM("")));
980     ASSERT_EQ(
981         false,
982         rtl::OUString().endsWithAsciiL(RTL_CONSTASCII_STRINGPARAM("foo")));
983     ASSERT_EQ(
984         true,
985         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bar")).endsWithAsciiL(
986             RTL_CONSTASCII_STRINGPARAM("bar")));
987     ASSERT_EQ(
988         true,
989         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foobar")).endsWithAsciiL(
990             RTL_CONSTASCII_STRINGPARAM("bar")));
991     ASSERT_EQ(
992         false,
993         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FOOBAR")).endsWithAsciiL(
994             RTL_CONSTASCII_STRINGPARAM("bar")));
995 }
996 
997 class createFromCodePoints: public ::testing::Test {
998 public:
999 };
1000 
TEST_F(createFromCodePoints,test)1001 TEST_F(createFromCodePoints, test) {
1002     ASSERT_EQ(
1003         sal_Int32(0),
1004         rtl::OUString(static_cast< sal_uInt32 const * >(NULL), 0).getLength());
1005     static sal_uInt32 const cp[] = { 0, 0xD800, 0xFFFF, 0x10000, 0x10FFFF };
1006     rtl::OUString s(cp, sizeof cp / sizeof (sal_uInt32));
1007     ASSERT_EQ(sal_Int32(7), s.getLength());
1008     ASSERT_EQ(sal_Unicode(0), s[0]);
1009     ASSERT_EQ(sal_Unicode(0xD800), s[1]);
1010     ASSERT_EQ(sal_Unicode(0xFFFF), s[2]);
1011     ASSERT_EQ(sal_Unicode(0xD800), s[3]);
1012     ASSERT_EQ(sal_Unicode(0xDC00), s[4]);
1013     ASSERT_EQ(sal_Unicode(0xDBFF), s[5]);
1014     ASSERT_EQ(sal_Unicode(0xDFFF), s[6]);
1015 }
1016 
1017 class iterateCodePoints: public ::testing::Test {
1018 public:
1019 };
1020 
TEST_F(iterateCodePoints,testNotWellFormed)1021 TEST_F(iterateCodePoints, testNotWellFormed) {
1022     static sal_Unicode const utf16[] =
1023         { 0xD800, 0xDC00, 0x0041, 0xDBFF, 0xDFFF, 0xDDEF, 0xD9AB };
1024     rtl::OUString s(utf16, sizeof utf16 / sizeof (sal_Unicode));
1025     sal_Int32 i = 0;
1026     ASSERT_EQ(sal_uInt32(0x10000), s.iterateCodePoints(&i));
1027     ASSERT_EQ(sal_Int32(2), i);
1028     ASSERT_EQ(sal_uInt32(0x0041), s.iterateCodePoints(&i));
1029     ASSERT_EQ(sal_Int32(3), i);
1030     ASSERT_EQ(sal_uInt32(0x10FFFF), s.iterateCodePoints(&i));
1031     ASSERT_EQ(sal_Int32(5), i);
1032     ASSERT_EQ(sal_uInt32(0xDDEF), s.iterateCodePoints(&i));
1033     ASSERT_EQ(sal_Int32(6), i);
1034     ASSERT_EQ(sal_uInt32(0xD9AB), s.iterateCodePoints(&i));
1035     ASSERT_EQ(sal_Int32(7), i);
1036     ASSERT_EQ(sal_uInt32(0xD9AB), s.iterateCodePoints(&i, -1));
1037     ASSERT_EQ(sal_Int32(6), i);
1038     ASSERT_EQ(sal_uInt32(0xDDEF), s.iterateCodePoints(&i, -1));
1039     ASSERT_EQ(sal_Int32(5), i);
1040     ASSERT_EQ(sal_uInt32(0x10FFFF), s.iterateCodePoints(&i, -1));
1041     ASSERT_EQ(sal_Int32(3), i);
1042     ASSERT_EQ(sal_uInt32(0x0041), s.iterateCodePoints(&i, -1));
1043     ASSERT_EQ(sal_Int32(2), i);
1044     ASSERT_EQ(sal_uInt32(0x10000), s.iterateCodePoints(&i, -1));
1045     ASSERT_EQ(sal_Int32(0), i);
1046     i = 1;
1047     ASSERT_EQ(sal_uInt32(0xDC00), s.iterateCodePoints(&i, 2));
1048     ASSERT_EQ(sal_Int32(3), i);
1049     i = 4;
1050     ASSERT_EQ(sal_uInt32(0x10000), s.iterateCodePoints(&i, -3));
1051     ASSERT_EQ(sal_Int32(0), i);
1052 }
1053 
1054 class convertFromString: public ::testing::Test {
1055 public:
1056 };
1057 
TEST_F(convertFromString,test)1058 TEST_F(convertFromString, test) {
1059     rtl::OUString t;
1060     ASSERT_TRUE(
1061         !rtl_convertStringToUString(
1062             &t.pData, RTL_CONSTASCII_STRINGPARAM("\x80"), RTL_TEXTENCODING_UTF8,
1063             (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR |
1064              RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR |
1065              RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)));
1066     ASSERT_TRUE(
1067         !rtl_convertStringToUString(
1068             &t.pData, RTL_CONSTASCII_STRINGPARAM("\xC0"), RTL_TEXTENCODING_UTF8,
1069             (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR |
1070              RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR |
1071              RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)));
1072     ASSERT_TRUE(
1073         !rtl_convertStringToUString(
1074             &t.pData, RTL_CONSTASCII_STRINGPARAM("\xFF"), RTL_TEXTENCODING_UTF8,
1075             (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR |
1076              RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR |
1077              RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)));
1078     ASSERT_TRUE(
1079         rtl_convertStringToUString(
1080             &t.pData, RTL_CONSTASCII_STRINGPARAM("abc"), RTL_TEXTENCODING_UTF8,
1081             (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR |
1082              RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR |
1083              RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)));
1084     ASSERT_TRUE(t.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("abc")));
1085 }
1086 
1087 
1088 } // namespace rtl_OUString
1089 
main(int argc,char ** argv)1090 int main(int argc, char **argv)
1091 {
1092     ::testing::InitGoogleTest(&argc, argv);
1093     return RUN_ALL_TESTS();
1094 }
1095