sal/qa/rtl/ostring/rtl_OString2.cxx

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