sal/qa/rtl/ostring/rtl_OString2.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: rtl_OString2.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_sal.hxx"
  34 // autogenerated file with codegen.pl
  35 // There exist some more test code in sal/qa/rtl_strings/rtl_OString.cxx
  36
  37 #include <cppunit/simpleheader.hxx>
  38 #include "valueequal.hxx"
  39
  40 namespace rtl_OString
  41 {
  42
  43 class valueOf : public CppUnit::TestFixture
  44 {
  45     void valueOf_float_test_impl(float _nValue)
  46         {
  47             rtl::OString sValue;
  48             sValue = rtl::OString::valueOf( _nValue );
  49             t_print(T_VERBOSE, "nFloat := %.9f  sValue := %s\n", _nValue, sValue.getStr());
  50
  51             float nValueATOF = static_cast<float>(atof( sValue.getStr() ));
  52
  53             bool bEqualResult = is_float_equal(_nValue, nValueATOF);
  54             CPPUNIT_ASSERT_MESSAGE("Values are not equal.", bEqualResult == true);
  55         }
  56
  57     void valueOf_float_test(float _nValue)
  58         {
  59             valueOf_float_test_impl(_nValue);
  60
  61             // test also the negative part.
  62             float nNegativeValue = -_nValue;
  63             valueOf_float_test_impl(nNegativeValue);
  64         }
  65
  66 public:
  67     // initialise your test code values here.
  68     void setUp()
  69     {
  70     }
  71
  72     void tearDown()
  73     {
  74     }
  75
  76     // insert your test code here.
  77     void valueOf_float_test_001()
  78     {
  79         // this is demonstration code
  80         // CPPUNIT_ASSERT_MESSAGE("a message", 1 == 1);
  81         float nValue = 3.0f;
  82         valueOf_float_test(nValue);
  83     }
  84
  85     void valueOf_float_test_002()
  86     {
  87         float nValue = 3.5f;
  88         valueOf_float_test(nValue);
  89     }
  90
  91     void valueOf_float_test_003()
  92     {
  93         float nValue = 3.0625f;
  94         valueOf_float_test(nValue);
  95     }
  96
  97     void valueOf_float_test_004()
  98     {
  99         float nValue = 3.502525f;
 100         valueOf_float_test(nValue);
 101     }
 102
 103     void valueOf_float_test_005()
 104     {
 105         float nValue = 3.141592f;
 106         valueOf_float_test(nValue);
 107     }
 108
 109     void valueOf_float_test_006()
 110     {
 111         float nValue = 3.5025255f;
 112         valueOf_float_test(nValue);
 113     }
 114
 115     void valueOf_float_test_007()
 116     {
 117         float nValue = 3.0039062f;
 118         valueOf_float_test(nValue);
 119     }
 120
 121 private:
 122
 123     void valueOf_double_test_impl(double _nValue)
 124         {
 125             rtl::OString sValue;
 126             sValue = rtl::OString::valueOf( _nValue );
 127             t_print(T_VERBOSE, "nDouble := %.20f  sValue := %s\n", _nValue, sValue.getStr());
 128
 129             double nValueATOF = atof( sValue.getStr() );
 130
 131             bool bEqualResult = is_double_equal(_nValue, nValueATOF);
 132             CPPUNIT_ASSERT_MESSAGE("Values are not equal.", bEqualResult == true);
 133         }
 134
 135     void valueOf_double_test(double _nValue)
 136         {
 137             valueOf_double_test_impl(_nValue);
 138
 139             // test also the negative part.
 140             double nNegativeValue = -_nValue;
 141             valueOf_double_test_impl(nNegativeValue);
 142         }
 143 public:
 144
 145     // valueOf double
 146     void valueOf_double_test_001()
 147         {
 148             double nValue = 3.0;
 149             valueOf_double_test(nValue);
 150         }
 151     void valueOf_double_test_002()
 152         {
 153             double nValue = 3.5;
 154             valueOf_double_test(nValue);
 155         }
 156     void valueOf_double_test_003()
 157         {
 158             double nValue = 3.0625;
 159             valueOf_double_test(nValue);
 160         }
 161     void valueOf_double_test_004()
 162         {
 163             double nValue = 3.1415926535;
 164             valueOf_double_test(nValue);
 165         }
 166     void valueOf_double_test_005()
 167         {
 168             double nValue = 3.141592653589793;
 169             valueOf_double_test(nValue);
 170         }
 171     void valueOf_double_test_006()
 172         {
 173             double nValue = 3.1415926535897932;
 174             valueOf_double_test(nValue);
 175         }
 176     void valueOf_double_test_007()
 177         {
 178             double nValue = 3.14159265358979323;
 179             valueOf_double_test(nValue);
 180         }
 181     void valueOf_double_test_008()
 182         {
 183             double nValue = 3.141592653589793238462643;
 184             valueOf_double_test(nValue);
 185         }
 186
 187
 188     // Change the following lines only, if you add, remove or rename
 189     // member functions of the current class,
 190     // because these macros are need by auto register mechanism.
 191
 192     CPPUNIT_TEST_SUITE(valueOf);
 193     CPPUNIT_TEST(valueOf_float_test_001);
 194     CPPUNIT_TEST(valueOf_float_test_002);
 195     CPPUNIT_TEST(valueOf_float_test_003);
 196     CPPUNIT_TEST(valueOf_float_test_004);
 197     CPPUNIT_TEST(valueOf_float_test_005);
 198     CPPUNIT_TEST(valueOf_float_test_006);
 199     CPPUNIT_TEST(valueOf_float_test_007);
 200
 201     CPPUNIT_TEST(valueOf_double_test_001);
 202     CPPUNIT_TEST(valueOf_double_test_002);
 203     CPPUNIT_TEST(valueOf_double_test_003);
 204     CPPUNIT_TEST(valueOf_double_test_004);
 205     CPPUNIT_TEST(valueOf_double_test_005);
 206     CPPUNIT_TEST(valueOf_double_test_006);
 207     CPPUNIT_TEST(valueOf_double_test_007);
 208     CPPUNIT_TEST(valueOf_double_test_008);
 209     CPPUNIT_TEST_SUITE_END();
 210 }; // class valueOf
 211
 212 // -----------------------------------------------------------------------------
 213 // - toDouble (tests)
 214 // -----------------------------------------------------------------------------
 215 class toDouble : public CppUnit::TestFixture
 216 {
 217
 218 public:
 219
 220     toDouble()
 221         {
 222             // testPrecision a;
 223         }
 224
 225
 226
 227     // initialise your test code values here.
 228     void setUp()
 229         {
 230         }
 231
 232     void tearDown()
 233         {
 234         }
 235
 236     void toDouble_test_impl(rtl::OString const& _sValue)
 237         {
 238             double nValueATOF = atof( _sValue.getStr() );
 239
 240             // rtl::OUString suValue = rtl::OUString::createFromAscii( _sValue.getStr() );
 241             double nValueToDouble = _sValue.toDouble();
 242
 243             bool bEqualResult = is_double_equal(nValueToDouble, nValueATOF);
 244             CPPUNIT_ASSERT_MESSAGE("Values are not equal.", bEqualResult == true);
 245         }
 246
 247     void toDouble_test(rtl::OString const& _sValue)
 248         {
 249             toDouble_test_impl(_sValue);
 250
 251             // test also the negativ part.
 252             rtl::OString sNegativValue("-");
 253             sNegativValue += _sValue;
 254             toDouble_test_impl(sNegativValue);
 255         }
 256
 257     // insert your test code here.
 258     void toDouble_selftest()
 259         {
 260             t_print("Start selftest:\n");
 261             CPPUNIT_ASSERT (is_double_equal(1.0, 1.01) == false);
 262             CPPUNIT_ASSERT (is_double_equal(1.0, 1.001) == false);
 263             CPPUNIT_ASSERT (is_double_equal(1.0, 1.0001) == false);
 264             CPPUNIT_ASSERT (is_double_equal(1.0, 1.00001) == false);
 265             CPPUNIT_ASSERT (is_double_equal(1.0, 1.000001) == false);
 266             CPPUNIT_ASSERT (is_double_equal(1.0, 1.0000001) == false);
 267             CPPUNIT_ASSERT (is_double_equal(1.0, 1.00000001) == false);
 268             CPPUNIT_ASSERT (is_double_equal(1.0, 1.000000001) == false);
 269             CPPUNIT_ASSERT (is_double_equal(1.0, 1.0000000001) == false);
 270             CPPUNIT_ASSERT (is_double_equal(1.0, 1.00000000001) == false);
 271             CPPUNIT_ASSERT (is_double_equal(1.0, 1.000000000001) == false);
 272             CPPUNIT_ASSERT (is_double_equal(1.0, 1.0000000000001) == false);
 273             // we check til 14 values after comma
 274             CPPUNIT_ASSERT (is_double_equal(1.0, 1.00000000000001) == true);
 275             CPPUNIT_ASSERT (is_double_equal(1.0, 1.000000000000001) == true);
 276             CPPUNIT_ASSERT (is_double_equal(1.0, 1.0000000000000001) == true);
 277             t_print("Selftest done.\n");
 278         }
 279
 280     void toDouble_test_3()
 281         {
 282             rtl::OString sValue("3");
 283             toDouble_test(sValue);
 284         }
 285     void toDouble_test_3_5()
 286         {
 287             rtl::OString sValue("3.5");
 288             toDouble_test(sValue);
 289         }
 290     void toDouble_test_3_0625()
 291         {
 292             rtl::OString sValue("3.0625");
 293             toDouble_test(sValue);
 294         }
 295     void toDouble_test_pi()
 296         {
 297             // value from http://www.angio.net/pi/digits/50.txt
 298             rtl::OString sValue("3.141592653589793238462643383279502884197169399375");
 299             toDouble_test(sValue);
 300         }
 301
 302     void toDouble_test_1()
 303         {
 304             rtl::OString sValue("1");
 305             toDouble_test(sValue);
 306         }
 307     void toDouble_test_10()
 308         {
 309             rtl::OString sValue("10");
 310             toDouble_test(sValue);
 311         }
 312     void toDouble_test_100()
 313         {
 314             rtl::OString sValue("100");
 315             toDouble_test(sValue);
 316         }
 317     void toDouble_test_1000()
 318         {
 319             rtl::OString sValue("1000");
 320             toDouble_test(sValue);
 321         }
 322     void toDouble_test_10000()
 323         {
 324             rtl::OString sValue("10000");
 325             toDouble_test(sValue);
 326         }
 327     void toDouble_test_1e99()
 328         {
 329             rtl::OString sValue("1e99");
 330             toDouble_test(sValue);
 331         }
 332     void toDouble_test_1e_n99()
 333         {
 334             rtl::OString sValue("1e-99");
 335             toDouble_test(sValue);
 336         }
 337     void toDouble_test_1e308()
 338         {
 339             rtl::OString sValue("1e308");
 340             toDouble_test(sValue);
 341         }
 342
 343     // Change the following lines only, if you add, remove or rename
 344     // member functions of the current class,
 345     // because these macros are need by auto register mechanism.
 346
 347     CPPUNIT_TEST_SUITE(toDouble);
 348     CPPUNIT_TEST(toDouble_selftest);
 349
 350     CPPUNIT_TEST(toDouble_test_3);
 351     CPPUNIT_TEST(toDouble_test_3_5);
 352     CPPUNIT_TEST(toDouble_test_3_0625);
 353     CPPUNIT_TEST(toDouble_test_pi);
 354     CPPUNIT_TEST(toDouble_test_1);
 355     CPPUNIT_TEST(toDouble_test_10);
 356     CPPUNIT_TEST(toDouble_test_100);
 357     CPPUNIT_TEST(toDouble_test_1000);
 358     CPPUNIT_TEST(toDouble_test_10000);
 359     CPPUNIT_TEST(toDouble_test_1e99);
 360     CPPUNIT_TEST(toDouble_test_1e_n99);
 361     CPPUNIT_TEST(toDouble_test_1e308);
 362     CPPUNIT_TEST_SUITE_END();
 363 }; // class toDouble
 364
 365 // -----------------------------------------------------------------------------
 366 // - getToken (tests)
 367 // -----------------------------------------------------------------------------
 368 class getToken : public CppUnit::TestFixture
 369 {
 370
 371 public:
 372
 373     // initialise your test code values here.
 374     void setUp()
 375         {
 376         }
 377
 378     void tearDown()
 379         {
 380         }
 381
 382     // -----------------------------------------------------------------------------
 383
 384     void getToken_000()
 385         {
 386             rtl::OString sTokenStr;
 387
 388             sal_Int32 nIndex = 0;
 389             do
 390             {
 391                 rtl::OString sToken = sTokenStr.getToken( 0, ';', nIndex );
 392             }
 393             while ( nIndex >= 0 );
 394             // t_print("Index %d\n", nIndex);
 395             // should not GPF
 396         }
 397
 398     void getToken_001()
 399         {
 400             rtl::OString sTokenStr = "a;b";
 401
 402             sal_Int32 nIndex = 0;
 403
 404             rtl::OString sToken = sTokenStr.getToken( 0, ';', nIndex );
 405             CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True);
 406
 407             /* rtl::OString */ sToken = sTokenStr.getToken( 0, ';', nIndex );
 408             CPPUNIT_ASSERT_MESSAGE("Token should be a 'b'", sToken.equals("b") == sal_True);
 409             CPPUNIT_ASSERT_MESSAGE("index should be negative", nIndex == -1);
 410         }
 411
 412     void getToken_002()
 413         {
 414             rtl::OString sTokenStr = "a;b.c";
 415
 416             sal_Int32 nIndex = 0;
 417
 418             rtl::OString sToken = sTokenStr.getToken( 0, ';', nIndex );
 419             CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True);
 420
 421             /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex );
 422             CPPUNIT_ASSERT_MESSAGE("Token should be a 'b'", sToken.equals("b") == sal_True);
 423
 424             /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex );
 425             CPPUNIT_ASSERT_MESSAGE("Token should be a 'c'", sToken.equals("c") == sal_True);
 426             CPPUNIT_ASSERT_MESSAGE("index should be negative", nIndex == -1);
 427         }
 428
 429     void getToken_003()
 430         {
 431             rtl::OString sTokenStr = "a;;b";
 432
 433             sal_Int32 nIndex = 0;
 434
 435             rtl::OString sToken = sTokenStr.getToken( 0, ';', nIndex );
 436             CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True);
 437
 438             /* rtl::OString */ sToken = sTokenStr.getToken( 0, ';', nIndex );
 439             CPPUNIT_ASSERT_MESSAGE("Token should be empty", sToken.getLength() == 0);
 440
 441             /* rtl::OString */ sToken = sTokenStr.getToken( 0, ';', nIndex );
 442             CPPUNIT_ASSERT_MESSAGE("Token should be a 'b'", sToken.equals("b") == sal_True);
 443             CPPUNIT_ASSERT_MESSAGE("index should be negative", nIndex == -1);
 444         }
 445
 446     void getToken_004()
 447         {
 448             rtl::OString sTokenStr = "longer.then.ever.";
 449
 450             sal_Int32 nIndex = 0;
 451
 452             rtl::OString sToken = sTokenStr.getToken( 0, '.', nIndex );
 453             CPPUNIT_ASSERT_MESSAGE("Token should be 'longer'", sToken.equals("longer") == sal_True);
 454
 455             /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex );
 456             CPPUNIT_ASSERT_MESSAGE("Token should be 'then'", sToken.equals("then") == sal_True);
 457
 458             /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex );
 459             CPPUNIT_ASSERT_MESSAGE("Token should be 'ever'", sToken.equals("ever") == sal_True);
 460
 461             /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex );
 462             CPPUNIT_ASSERT_MESSAGE("Token should be empty", sToken.getLength() == 0);
 463
 464             CPPUNIT_ASSERT_MESSAGE("index should be negative", nIndex == -1);
 465         }
 466
 467
 468     CPPUNIT_TEST_SUITE(getToken);
 469     CPPUNIT_TEST(getToken_000);
 470     CPPUNIT_TEST(getToken_001);
 471     CPPUNIT_TEST(getToken_002);
 472     CPPUNIT_TEST(getToken_003);
 473     CPPUNIT_TEST(getToken_004);
 474     CPPUNIT_TEST_SUITE_END();
 475 }; // class getToken
 476
 477 // -----------------------------------------------------------------------------
 478 // testing the method replaceAt( sal_Int32 index, sal_Int32 count,
 479 // const OString& newStr )
 480 // -----------------------------------------------------------------------------
 481
 482 // Developer note: Mindy Liu, 2004-04-23
 483 // stollen from sal/qa/rtl_strings/rtl_OString.cxx
 484
 485 class replaceAt : public CppUnit::TestFixture
 486 {
 487
 488 public:
 489     // initialise your test code values here.
 490     void setUp()
 491         {
 492         }
 493
 494     void tearDown()
 495         {
 496         }
 497     sal_Bool check_replaceAt( const rtl::OString* expVal, const rtl::OString* input,
 498         const rtl::OString* newStr, sal_Int32  index, sal_Int32 count)
 499     {
 500          ::rtl::OString aStr1;
 501         aStr1= input->replaceAt( index, count, *newStr );
 502
 503         t_print("the result OString is %s#\n", aStr1.getStr() );
 504
 505         sal_Bool bRes = ( expVal->compareTo(aStr1) == 0 );
 506         return bRes;
 507     }
 508     // -----------------------------------------------------------------------------
 509
 510    void replaceAt_001()
 511         {
 512         sal_Bool bRes = check_replaceAt(new rtl::OString("Java@Sun"),
 513             new rtl::OString("Sun java"), new rtl::OString("Java@Sun"), 0, 8 );
 514             CPPUNIT_ASSERT_MESSAGE("string differs, replace whole string", bRes == sal_True);
 515         }
 516
 517     void replaceAt_002()
 518         {
 519             sal_Bool bRes = check_replaceAt(new rtl::OString("Sun Java desktop system"),
 520             new rtl::OString("Sun "), new rtl::OString("Java desktop system"), 10, 8 );
 521             CPPUNIT_ASSERT_MESSAGE("index > length of input string", bRes == sal_True);
 522         }
 523
 524     void replaceAt_003()
 525         {
 526             sal_Bool bRes = check_replaceAt(new rtl::OString("SuJava desktop system"),
 527             new rtl::OString("Sun "), new rtl::OString("Java desktop system"), 2, 64 );
 528             CPPUNIT_ASSERT_MESSAGE("larger count", bRes == sal_True);
 529         }
 530
 531     void replaceAt_004()
 532         {
 533
 534             sal_Bool bRes = check_replaceAt(new rtl::OString("Java desktop system"),
 535             new rtl::OString("Sun "), new rtl::OString("Java desktop system"), -4, 8 );
 536             CPPUNIT_ASSERT_MESSAGE("navigate index", bRes == sal_True);
 537         }
 538     void replaceAt_005()
 539         {
 540
 541             sal_Bool bRes = check_replaceAt(new rtl::OString("Sun Jesktop System"),
 542             new rtl::OString("Sun Java Desktop System"), new rtl::OString(""), 5, 5 );
 543             CPPUNIT_ASSERT_MESSAGE("replace with null string", bRes == sal_True);
 544         }
 545
 546
 547     CPPUNIT_TEST_SUITE(replaceAt);
 548     CPPUNIT_TEST(replaceAt_001);
 549     CPPUNIT_TEST(replaceAt_002);
 550     CPPUNIT_TEST(replaceAt_003);
 551     CPPUNIT_TEST(replaceAt_004);
 552     CPPUNIT_TEST(replaceAt_005);
 553     CPPUNIT_TEST_SUITE_END();
 554 }; // class replaceAt
 555
 556
 557 // -----------------------------------------------------------------------------
 558 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_OString::valueOf, "rtl_OString");
 559 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_OString::toDouble, "rtl_OString");
 560 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_OString::getToken, "rtl_OString");
 561 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_OString::replaceAt, "rtl_OString");
 562
 563 } // namespace rtl_OString
 564
 565
 566 // -----------------------------------------------------------------------------
 567
 568 // this macro creates an empty function, which will called by the RegisterAllFunctions()
 569 // to let the user the possibility to also register some functions by hand.
 570 NOADDITIONAL;
 571