sal/qa/ByteSequence/ByteSequence.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: ByteSequence.cxx,v $
  10  * $Revision: 1.13 $
  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 #include <Byte_Const.h>
  35 #include <rtl/byteseq.h>
  36
  37 #include <rtl/byteseq.hxx>
  38
  39 #include <cppunit/simpleheader.hxx>
  40
  41 using namespace rtl;
  42
  43 namespace rtl_ByteSequence
  44 {
  45
  46 //------------------------------------------------------------------------
  47 // testing constructors
  48 //------------------------------------------------------------------------
  49
  50 class  ctor : public CppUnit::TestFixture
  51     {
  52     public:
  53
  54         void ctor_001()
  55         {
  56             ::rtl::ByteSequence aByteSeq1;
  57         ::rtl::ByteSequence aByteSeq2( &kTestEmptyByteSeq );
  58             CPPUNIT_ASSERT_MESSAGE
  59             (
  60                 "Creates an empty sequence",
  61                 aByteSeq1.getLength() == 0 &&
  62                 aByteSeq1 == aByteSeq2
  63             );
  64         }
  65
  66         void ctor_002()
  67         {
  68             ::rtl::ByteSequence aByteSeq;
  69             ::rtl::ByteSequence aByteSeqtmp( aByteSeq );
  70             CPPUNIT_ASSERT_MESSAGE
  71             (
  72                 "Creates a copy of given sequence",
  73                 aByteSeq == aByteSeqtmp
  74             );
  75
  76         }
  77
  78         void ctor_003()
  79         {
  80             ::rtl::ByteSequence aByteSeq( &kTestByteSeq1 );
  81         sal_Int32 nNewLen = aByteSeq.getLength();
  82             CPPUNIT_ASSERT_MESSAGE
  83             (
  84                 "Copy constructor Creates a copy from the C-Handle ",
  85                 nNewLen == kTestSeqLen1
  86         );
  87         }
  88
  89     void ctor_003_1()
  90         {
  91             ::rtl::ByteSequence aByteSeq( &kTestByteSeq2 );
  92         sal_Int32 nNewLen = aByteSeq.getLength();
  93             CPPUNIT_ASSERT_MESSAGE
  94             (
  95                 "Copy constructor Creates a copy from the C-Handle: reference count > 1 ",
  96                 nNewLen == kTestSeqLen2
  97         );
  98         }
  99
 100         void ctor_004()
 101         {
 102             sal_Int8 * pElements = &kTestByte4;
 103         sal_Int32 len = kTestByteCount1;
 104         ::rtl::ByteSequence aByteSeq( pElements, len);
 105         sal_Int32 nNewLen = aByteSeq.getLength();
 106             CPPUNIT_ASSERT_MESSAGE
 107             (
 108                 "Creates a copy of given data bytes",
 109                 aByteSeq[1] == pElements[1] &&
 110                 len == nNewLen
 111
 112             );
 113         }
 114
 115     void ctor_005()
 116         {
 117         sal_Int32 len = 50;
 118             ::rtl::ByteSequence aByteSeq( len );
 119         sal_Int32 nNewLen = aByteSeq.getLength();
 120         sal_Bool res = sal_True;
 121         for (sal_Int32 i=0; i<len; i++)
 122         {
 123                 if (aByteSeq[i] != 0)
 124                     res = sal_False;
 125             }
 126             CPPUNIT_ASSERT_MESSAGE
 127             (
 128                 "Creates sequence of given length and initializes all bytes to 0",
 129                 nNewLen == len && res
 130
 131             );
 132         }
 133
 134         void ctor_006()
 135         {
 136         sal_Int32 len = 39;
 137             ::rtl::ByteSequence aByteSeq( len , BYTESEQ_NODEFAULT );
 138             sal_Int32 nNewLen = aByteSeq.getLength();
 139             CPPUNIT_ASSERT_MESSAGE
 140             (
 141                 "Creates sequence of given length and does NOT initialize data",
 142                 nNewLen == len
 143
 144             );
 145         }
 146
 147         void ctor_007()
 148         {
 149             ::rtl::ByteSequence aByteSeq( &kTestByteSeq3, BYTESEQ_NOACQUIRE );
 150         sal_Int32 nNewLen = aByteSeq.getLength();
 151             CPPUNIT_ASSERT_MESSAGE
 152             (
 153                 "Creates a sequence from a C-Handle without acquiring the handle, thus taking over ownership",
 154                 nNewLen == kTestSeqLen3
 155             );
 156         }
 157
 158         CPPUNIT_TEST_SUITE(ctor);
 159         CPPUNIT_TEST(ctor_001);
 160         CPPUNIT_TEST(ctor_002);
 161         CPPUNIT_TEST(ctor_003);
 162     CPPUNIT_TEST(ctor_003_1);
 163         CPPUNIT_TEST(ctor_004);
 164         CPPUNIT_TEST(ctor_005);
 165         CPPUNIT_TEST(ctor_006);
 166         CPPUNIT_TEST(ctor_007);
 167         CPPUNIT_TEST_SUITE_END();
 168     };
 169
 170 class assign : public CppUnit::TestFixture
 171 {
 172 public:
 173     // initialise your test code values here.
 174     void setUp()
 175     {
 176     }
 177
 178     void tearDown()
 179     {
 180     }
 181
 182     // insert your test code here.
 183     void assign_001()
 184     {
 185     sal_Int32 len = kTestByteCount1;
 186     sal_Int32 len2 = len - 1;
 187     sal_Int8 * pElements = &kTestByte;
 188     ::rtl::ByteSequence aByteSeq1( kTestByte5, len);
 189     ::rtl::ByteSequence aByteSeq2( pElements, len2);
 190     aByteSeq2 = aByteSeq1;
 191     sal_Int32 nNewLen = aByteSeq2.getLength();
 192         CPPUNIT_ASSERT_MESSAGE
 193         (
 194             "Assignment operator: assign longer sequence to another",
 195             aByteSeq1 == aByteSeq2 &&
 196             nNewLen == len
 197         );
 198     }
 199
 200     void assign_002()
 201     {
 202         sal_Int32 len = kTestByteCount1 - 1 ;
 203         ::rtl::ByteSequence aByteSeq1( len );
 204     sal_Int8 * pElements = &kTestByte1;
 205     ::rtl::ByteSequence aByteSeq2( pElements, len + 1);
 206     aByteSeq2 = aByteSeq1;
 207     sal_Int32 nNewLen = aByteSeq2.getLength();
 208         CPPUNIT_ASSERT_MESSAGE
 209         (
 210             "Assignment operator: assign shorter sequence to another",
 211             aByteSeq1 == aByteSeq2 &&
 212             nNewLen == len
 213         );
 214     }
 215
 216     void assign_003()
 217     {
 218         sal_Int32 len = kTestByteCount1 - 1 ;
 219     const sal_Int8 * pElements = &kTestByte2;
 220         ::rtl::ByteSequence aByteSeq1( pElements, len + 1 );
 221     ::rtl::ByteSequence aByteSeq2( len, BYTESEQ_NODEFAULT );
 222     aByteSeq2 = aByteSeq1;
 223     sal_Int32 nNewLen = aByteSeq2.getLength();
 224         CPPUNIT_ASSERT_MESSAGE
 225         (
 226             "Assignment operator: assign sequence to another sequence having no data initialized",
 227             aByteSeq1 == aByteSeq2 &&
 228             nNewLen == kTestByteCount1
 229         );
 230     }
 231
 232     void assign_004()
 233     {
 234         ::rtl::ByteSequence aByteSeq1;
 235     sal_Int32 len = kTestByteCount1 ;
 236     const sal_Int8 * pElements = &kTestByte;
 237     ::rtl::ByteSequence aByteSeq2( pElements, len);
 238     aByteSeq2 = aByteSeq1;
 239     sal_Int32 nNewLen = aByteSeq2.getLength();
 240         CPPUNIT_ASSERT_MESSAGE
 241         (
 242             "Assignment operator: assign empty sequence to another not empty sequence",
 243             aByteSeq1 == aByteSeq2 &&
 244         nNewLen == 0
 245         );
 246     }
 247
 248     CPPUNIT_TEST_SUITE(assign);
 249     CPPUNIT_TEST(assign_001);
 250     CPPUNIT_TEST(assign_002);
 251     CPPUNIT_TEST(assign_003);
 252     CPPUNIT_TEST(assign_004);
 253     CPPUNIT_TEST_SUITE_END();
 254 }; // class operator=
 255
 256
 257 class equal : public CppUnit::TestFixture
 258 {
 259 public:
 260     // initialise your test code values here.
 261     void setUp()
 262     {
 263     }
 264
 265     void tearDown()
 266     {
 267     }
 268
 269     // insert your test code here.
 270     void equal_001()
 271     {
 272     sal_Int32 len = kTestByteCount1 ;
 273         sal_Int8 * pElements = &kTestByte;
 274     ::rtl::ByteSequence aByteSeq1( pElements, len-1);
 275     ::rtl::ByteSequence aByteSeq2( pElements, len);
 276     sal_Bool res = aByteSeq1 == aByteSeq2;
 277         CPPUNIT_ASSERT_MESSAGE
 278         (
 279             "Equality operator: compare two sequences 1",
 280             !res
 281         );
 282     }
 283
 284     void equal_002()
 285     {
 286         sal_Int32 len = kTestByteCount1 ;
 287         const sal_Int8 * pElements = &kTestByte;
 288     ::rtl::ByteSequence aByteSeq1( pElements, len);
 289     ::rtl::ByteSequence aByteSeq2( pElements, len);
 290     sal_Bool res = aByteSeq1 == aByteSeq2;
 291         CPPUNIT_ASSERT_MESSAGE
 292         (
 293             "Equality operator: compare two sequences 2",
 294             res
 295         );
 296     }
 297
 298     void equal_003()
 299     {
 300         sal_Int32 len = kTestByteCount1 ;
 301         const sal_Int8 * pElements = kTestByte5;
 302     ::rtl::ByteSequence aByteSeq1( pElements, len);
 303     pElements = kTestByte6;
 304     ::rtl::ByteSequence aByteSeq2( pElements, len);
 305     sal_Bool res = aByteSeq1 == aByteSeq2;
 306         CPPUNIT_ASSERT_MESSAGE
 307         (
 308             "Equality operator: compare two sequences 2",
 309             !res
 310         );
 311     }
 312     CPPUNIT_TEST_SUITE(equal);
 313     CPPUNIT_TEST(equal_001);
 314     CPPUNIT_TEST(equal_002);
 315     CPPUNIT_TEST(equal_003);
 316     CPPUNIT_TEST_SUITE_END();
 317 }; // class equal
 318
 319
 320 class notequal : public CppUnit::TestFixture
 321 {
 322 public:
 323     // initialise your test code values here.
 324     void setUp()
 325     {
 326     }
 327
 328     void tearDown()
 329     {
 330     }
 331
 332     // insert your test code here.
 333     void notequal_001()
 334     {
 335         sal_Int32 len = kTestByteCount1 ;
 336         const sal_Int8 * pElements = &kTestByte;
 337     ::rtl::ByteSequence aByteSeq1( pElements, len-1);
 338     ::rtl::ByteSequence aByteSeq2( pElements, len);
 339     sal_Bool res = aByteSeq1 != aByteSeq2;
 340         CPPUNIT_ASSERT_MESSAGE
 341         (
 342             "Equality operator: compare two sequences 1",
 343             res
 344         );
 345     }
 346
 347     void notequal_002()
 348     {
 349         sal_Int32 len = kTestByteCount1 ;
 350         const sal_Int8 * pElements = &kTestByte;
 351     ::rtl::ByteSequence aByteSeq1( pElements, len);
 352     ::rtl::ByteSequence aByteSeq2( pElements, len);
 353     sal_Bool res = aByteSeq1 != aByteSeq2;
 354         CPPUNIT_ASSERT_MESSAGE
 355         (
 356             "Equality operator: compare two sequences 2",
 357             !res
 358         );
 359     }
 360
 361     CPPUNIT_TEST_SUITE(notequal);
 362     CPPUNIT_TEST(notequal_001);
 363     CPPUNIT_TEST(notequal_002);
 364     CPPUNIT_TEST_SUITE_END();
 365 }; // class notequal
 366
 367
 368 class getArray : public CppUnit::TestFixture
 369 {
 370 public:
 371     // initialise your test code values here.
 372     void setUp()
 373     {
 374     }
 375
 376     void tearDown()
 377     {
 378     }
 379
 380     // insert your test code here.
 381     void getArray_001()
 382     {
 383         sal_Int32 len = kTestByteCount1 ;
 384         sal_Int8 * pElements = &kTestByte;
 385     ::rtl::ByteSequence aByteSeq1( pElements, len);
 386     sal_Int8 * pArray = aByteSeq1.getArray();
 387     sal_Bool res = sal_True;
 388     for (sal_Int32 i = 0; i < len; i++)
 389     {
 390         if (pElements[i] != pArray[i])
 391         res = sal_False;
 392     }
 393     CPPUNIT_ASSERT_MESSAGE
 394         (
 395             "Gets the pointer to byte array: one element sequence",
 396         res == sal_True
 397         );
 398     }
 399
 400     void getArray_002()
 401     {
 402     sal_Int8 * pElements = kTestByte6;
 403         ::rtl::ByteSequence aByteSeq(pElements, 5);
 404     sal_Int8 * pArray = aByteSeq.getArray();
 405     sal_Bool res = sal_True;
 406     for (sal_Int32 i = 0; i < 5; i++)
 407     {
 408         if (pElements[i] != pArray[i])
 409         res = sal_False;
 410     }
 411     CPPUNIT_ASSERT_MESSAGE
 412         (
 413             "Gets the pointer to byte array: more elements sequence",
 414             res == sal_True
 415         );
 416     }
 417
 418     CPPUNIT_TEST_SUITE(getArray);
 419     CPPUNIT_TEST(getArray_001);
 420     CPPUNIT_TEST(getArray_002);
 421     CPPUNIT_TEST_SUITE_END();
 422 }; // class getArray
 423
 424
 425 class realloc : public CppUnit::TestFixture
 426 {
 427 public:
 428     // initialise your test code values here.
 429     void setUp()
 430     {
 431     }
 432
 433     void tearDown()
 434     {
 435     }
 436
 437     // insert your test code here.
 438     void realloc_001()
 439     {
 440         ::rtl::ByteSequence aByteSeq;
 441     sal_Int32 nSize = 20;
 442     aByteSeq.realloc( nSize );
 443     sal_Int32 nNewLen = aByteSeq.getLength();
 444         CPPUNIT_ASSERT_MESSAGE
 445         (
 446             "Reallocates sequence to new length: empty sequence",
 447             nNewLen == nSize
 448         );
 449     }
 450
 451     void realloc_002()
 452     {
 453     //reference count > 1
 454     ::rtl::ByteSequence aByteSeq( &kTestByteSeq2 );  //34
 455     sal_Int32 nSize = 20;
 456     aByteSeq.realloc( nSize );
 457     sal_Int32 nNewLen = aByteSeq.getLength();
 458     CPPUNIT_ASSERT_MESSAGE
 459         (
 460             "Reallocates sequence: reference count > 1 && nSize < nElements",
 461             nNewLen == nSize
 462         );
 463     }
 464
 465     void realloc_003()
 466     {
 467     //reference count > 1
 468     ::rtl::ByteSequence aByteSeq( &kTestByteSeq2 );  //34
 469     sal_Int32 nSize = kTestSeqLen2 + 5;
 470     sal_Int32 nElements = kTestSeqLen2;
 471     aByteSeq.realloc( nSize );
 472     sal_Int32 nNewLen = aByteSeq.getLength();
 473     sal_Bool res = sal_True;
 474     for (int i = nSize; i < nElements; i++)
 475     {
 476             sal_Int8 nValue = aByteSeq[i];
 477         if (nValue != 0)
 478                 res = sal_False;
 479         }
 480     CPPUNIT_ASSERT_MESSAGE
 481         (
 482             "Reallocates sequence: reference count > 1 && nSize > nElements",
 483             nNewLen == nSize
 484         && res == sal_True
 485         );
 486     }
 487
 488     void realloc_004()
 489     {
 490     sal_Int8 * pElements = &kTestByte3;
 491     sal_Int32 len = kTestByteCount3;
 492     ::rtl::ByteSequence aByteSeq( pElements, len);
 493     sal_Int32 nSize = kTestByteCount3 - 10 ;
 494     aByteSeq.realloc( nSize );
 495     sal_Int32 nNewLen = aByteSeq.getLength();
 496     CPPUNIT_ASSERT_MESSAGE
 497         (
 498             "Reallocates sequence: nSize < nElements",
 499             nNewLen == nSize
 500         );
 501     }
 502
 503     void realloc_005()
 504     {
 505     sal_Int8 * pElements = kTestByte6;
 506     sal_Int32 len = 4;
 507     ::rtl::ByteSequence aByteSeq( pElements, len);
 508     sal_Int32 nSize = len + 10 ;
 509     aByteSeq.realloc( nSize );
 510     sal_Int32 nNewLen = aByteSeq.getLength();
 511     CPPUNIT_ASSERT_MESSAGE
 512         (
 513             "Reallocates sequence: nSize > nElements",
 514             nNewLen == nSize
 515         );
 516     }
 517
 518     CPPUNIT_TEST_SUITE(realloc);
 519     CPPUNIT_TEST(realloc_001);
 520     CPPUNIT_TEST(realloc_002);
 521     CPPUNIT_TEST(realloc_003);
 522     CPPUNIT_TEST(realloc_004);
 523     CPPUNIT_TEST(realloc_005);
 524     //CPPUNIT_TEST(realloc_006);
 525     CPPUNIT_TEST_SUITE_END();
 526 }; // class realloc
 527
 528
 529 class getData : public CppUnit::TestFixture
 530 {
 531 public:
 532     // initialise your test code values here.
 533     void setUp()
 534     {
 535     }
 536
 537     void tearDown()
 538     {
 539     }
 540
 541     // insert your test code here.
 542     void getData_001()
 543     {
 544     sal_Int8 * pElements = kTestByte5;
 545         ::rtl::ByteSequence aByteSeq(pElements, 4);
 546     sal_Bool res = sal_True;
 547     if (aByteSeq[0] != kTestByte)
 548             res = sal_False;
 549
 550         if (aByteSeq[1] != kTestByte1)
 551             res = sal_False;
 552
 553     if (aByteSeq[2] != kTestByte2)
 554             res = sal_False;
 555
 556     if (aByteSeq[3] != kTestByte3)
 557             res = sal_False;
 558
 559     CPPUNIT_ASSERT_MESSAGE
 560         (
 561             "Obtains a reference to byte indexed at given position: empty sequence",
 562             res == sal_True
 563         );
 564     }
 565
 566     void getData_002()
 567     {
 568         ::rtl::ByteSequence aByteSeq( &kTestByteSeq2 );
 569     sal_Int8 nValue = aByteSeq[0];
 570         CPPUNIT_ASSERT_MESSAGE
 571         (
 572             "Obtains a reference to byte indexed at given position: reference count > 1",
 573             nValue == kTestChar2 //not sure what is right,hehe
 574     );
 575     }
 576
 577     void getData_003()
 578     {
 579         ::rtl::ByteSequence aByteSeq( &kTestByteSeq3 );
 580     sal_Int8 nValue = aByteSeq[0];
 581         CPPUNIT_ASSERT_MESSAGE
 582         (
 583             "Obtains a reference to byte indexed at given position: reference count = 1",
 584             nValue == kTestChar3 //not sure what is right,hehe
 585     );
 586     }
 587
 588     CPPUNIT_TEST_SUITE(getData);
 589     CPPUNIT_TEST(getData_001);
 590     CPPUNIT_TEST(getData_002);
 591     CPPUNIT_TEST(getData_003);
 592     CPPUNIT_TEST_SUITE_END();
 593 }; // class getData
 594
 595 // -----------------------------------------------------------------------------
 596 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ByteSequence::ctor, "rtl_ByteSequence");
 597 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ByteSequence::assign, "rtl_ByteSequence");
 598 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ByteSequence::equal, "rtl_ByteSequence");
 599 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ByteSequence::notequal, "rtl_ByteSequence");
 600 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ByteSequence::getArray, "rtl_ByteSequence");
 601 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ByteSequence::realloc, "rtl_ByteSequence");
 602 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ByteSequence::getData, "rtl_ByteSequence");
 603 } // namespace ByteSequence
 604
 605
 606 // -----------------------------------------------------------------------------
 607
 608 // this macro creates an empty function, which will called by the RegisterAllFunctions()
 609 // to let the user the possibility to also register some functions by hand.
 610 NOADDITIONAL;