LTP GCOV extension - code coverage report
Current view: directory - test/cpp/unit/cdr/write - TestCdrWrite.cpp
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 172
Code covered: 89.0 % Executed lines: 153

       1                 : //==============================================================================
       2                 : // File <$/test/cpp/unit/cdr/write/TestCdrWrite.cpp>
       3                 : // This file is part of YaOrb : Yet Another Object Request Broker,
       4                 : // Copyright (c) 2000-2003, Marc Alff.
       5                 : //
       6                 : // This program is free software; you can redistribute it and/or
       7                 : // modify it under the terms of the GNU General Public License
       8                 : // as published by the Free Software Foundation; either version 2
       9                 : // of the License, or (at your option) any later version.
      10                 : //
      11                 : // This program is distributed in the hope that it will be useful,
      12                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 : // GNU General Public License for more details.
      15                 : //
      16                 : // You should have received a copy of the GNU General Public License
      17                 : // along with this program; if not, write to the Free Software
      18                 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
      19                 : //
      20                 : //==============================================================================
      21                 : 
      22                 : #include "yaorb/CORBA.h"
      23                 : #include "yaorb/YAORB.h"
      24                 : #include "src/cpp/prod/tool/String.h"
      25                 : #include "src/cpp/prod/protocol/cdr/cdr_file.h"
      26                 : 
      27                 : void
      28               2 : TestBool(YAORB::CDR *cdr)
      29                 : {
      30                 :    CORBA::Boolean b ;
      31                 :    CORBA::Boolean bArray[8] ;
      32                 :    int size = 8 ;
      33                 :    int middle = 3 ;
      34                 :    int i ;
      35                 : 
      36                 :    // Expecting to write :
      37                 :    // T, F, T (*3), F (*5)
      38                 :    // --> 0x01 0x00 0x01 0x01 0x01 0x00 0x00 0x00
      39                 :    //     0x00 0x00
      40                 :    // 10 bytes total.
      41                 : 
      42               2 :    b = true ;
      43               2 :    cdr->cdr_Boolean(& b) ;
      44                 : 
      45               2 :    b = false ;
      46               2 :    cdr->cdr_Boolean(& b) ;
      47                 : 
      48                 : #ifdef LATER
      49                 :    // Expecting to write True = 1 or throw marshall ?
      50                 :    char *hackPrt = (char*) & b ;
      51                 :    *hackPrt = 12 ;
      52                 :    cdr->cdr_Boolean(& b) ;
      53                 : #endif
      54                 : 
      55               6 :    for (i = 0 ; i < middle ; i++)
      56                 :    {
      57               6 :       bArray[i] = true ;
      58                 :    }
      59                 : 
      60              10 :    for (i = middle ; i < size ; i++)
      61                 :    {
      62              10 :       bArray[i] = false ;
      63                 :    }
      64                 : 
      65               2 :    cdr->cdr_BooleanArray(& bArray[0], size) ;
      66                 : 
      67                 :    return ;
      68                 : }
      69                 : 
      70                 : void
      71               2 : TestOctet(YAORB::CDR *cdr)
      72                 : {
      73                 :    CORBA::Octet o ;
      74                 :    CORBA::Octet oArray[5] ;
      75                 : 
      76                 :    // Expecting to write :
      77                 :    // 0x10 0x20 0xAA 0xBB 0xCC 0x0F 0xF0
      78                 :    // 7 bytes total.
      79                 : 
      80               2 :    o = 0x10 ;
      81               2 :    cdr->cdr_Octet(& o) ;
      82                 : 
      83               2 :    o = 0x20 ;
      84               2 :    cdr->cdr_Octet(& o) ;
      85                 : 
      86               2 :    oArray[0] = 0xAA ;
      87               2 :    oArray[1] = 0xBB ;
      88               2 :    oArray[2] = 0xCC ;
      89               2 :    oArray[3] = 0x0F ;
      90               2 :    oArray[4] = 0xF0 ;
      91                 : 
      92               2 :    cdr->cdr_OctetArray(& oArray[0], 5) ;
      93                 : }
      94                 : 
      95                 : void
      96               2 : TestChar(YAORB::CDR *cdr)
      97                 : {
      98                 :    CORBA::Char c ;
      99                 :    CORBA::Char cArray[4] ;
     100                 : 
     101                 :    // Expecting to write :
     102                 :    // 'a' 'b' 'A' 'B' 'C' 'D'
     103                 :    // --> 0x61 0x62 0x41 0x42 0x43 0x44
     104                 :    // 6 bytes total.
     105                 : 
     106               2 :    c = 'a' ;
     107               2 :    cdr->cdr_Char(& c) ;
     108                 : 
     109               2 :    c = 'b' ;
     110               2 :    cdr->cdr_Char(& c) ;
     111                 : 
     112               2 :    cArray[0] = 'A' ;
     113               2 :    cArray[1] = 'B' ;
     114               2 :    cArray[2] = 'C' ;
     115               2 :    cArray[3] = 'D' ;
     116                 : 
     117               2 :    cdr->cdr_CharArray(& cArray[0], 4) ;
     118                 : }
     119                 : 
     120                 : void
     121               0 : TestWChar(YAORB::CDR *cdr)
     122                 : {
     123                 :    CORBA::WChar wc ;
     124                 :    CORBA::WChar wcArray[4] ;
     125                 : 
     126                 :    // Expecting to write :
     127                 :    // L'a' L'b' L'A' L'B' L'C' L'D'
     128                 :    // --> 0x??61 0x??62 0x??41 0x??42 0x??43 0x??44
     129                 :    // FIXME : depend on character transmission set
     130                 :    // ?? bytes total.
     131                 : 
     132               0 :    wc = L'a' ;
     133               0 :    cdr->cdr_WChar(& wc) ;
     134                 : 
     135               0 :    wc = L'b' ;
     136               0 :    cdr->cdr_WChar(& wc) ;
     137                 : 
     138               0 :    wcArray[0] = L'A' ;
     139               0 :    wcArray[1] = L'B' ;
     140               0 :    wcArray[2] = L'C' ;
     141               0 :    wcArray[3] = L'D' ;
     142                 : 
     143               0 :    cdr->cdr_WCharArray(& wcArray[0], 4) ;
     144                 : }
     145                 : 
     146                 : void
     147               2 : TestShort(YAORB::CDR *cdr)
     148                 : {
     149                 :    CORBA::Short s ;
     150                 :    CORBA::Short sArray[3] ;
     151                 : 
     152                 :    // Expecting to write :
     153                 :    // 0x0102 0xFCFC 0x51A2 0x9E4E 0x71C2
     154                 :    // be --> 0x01 0x02 0xFC 0xFC 0x51 0xA2 0x9E 0x4E
     155                 :    //        0x71 0xC2
     156                 :    // le --> 0x02 0x01 0xFC 0xFC 0xA2 0x51 0x4E 0x9E
     157                 :    //        0xC2 0x71
     158                 :    // 10 bytes total.
     159                 : 
     160               2 :    s = 0x0102 ;
     161               2 :    cdr->cdr_Short(& s) ;
     162                 : 
     163               2 :    s = - 0x0304 ; // --> 0xFCFC
     164               2 :    cdr->cdr_Short(& s) ;
     165                 : 
     166               2 :    sArray[0] = 0x51A2 ;
     167               2 :    sArray[1] = - 0x61B2 ; // --> 0x9E4E
     168               2 :    sArray[2] = 0x71C2 ;
     169                 : 
     170               2 :    cdr->cdr_ShortArray(& sArray[0], 3) ;
     171                 : }
     172                 : 
     173                 : void
     174               2 : TestUShort(YAORB::CDR *cdr)
     175                 : {
     176                 :    CORBA::UShort us ;
     177                 :    CORBA::UShort usArray[3] ;
     178                 : 
     179                 :    // Expecting to write :
     180                 :    // 0x0102 0x0304 0xA1A2 0xB1B2 0xC1C2
     181                 :    // be --> 0x01 0x02 0x03 0x04 0xA1 0xA2 0xB1 0xB2
     182                 :    //        0xC1 0xC2
     183                 :    // le --> 0x02 0x01 0x04 0x03 0xA2 0xA1 0xB2 0xB1
     184                 :    //        0xC2 0xC1
     185                 :    // 10 bytes total.
     186                 : 
     187               2 :    us = 0x0102 ;
     188               2 :    cdr->cdr_UShort(& us) ;
     189                 : 
     190               2 :    us = 0x0304 ;
     191               2 :    cdr->cdr_UShort(& us) ;
     192                 : 
     193               2 :    usArray[0] = 0xA1A2 ;
     194               2 :    usArray[1] = 0xB1B2 ;
     195               2 :    usArray[2] = 0xC1C2 ;
     196                 : 
     197               2 :    cdr->cdr_UShortArray(& usArray[0], 3) ;
     198                 : }
     199                 : 
     200                 : void
     201               2 : TestLong(YAORB::CDR *cdr)
     202                 : {
     203                 :    CORBA::Long l ;
     204                 :    CORBA::Long lArray[3] ;
     205                 : 
     206                 :    // Expecting to write :
     207                 :    // 0x01020304 0xFAF9F8F8 0x51A2A3A4 0x9E4D4C4C 0x71C2C3C4
     208                 :    // be --> 0x01 0x02 0x03 0x04 0xFA 0xF9 0xF8 0xF8
     209                 :    //        0x51 0xA2 0xA3 0xA4 0x9E 0x4D 0x4C 0x4C
     210                 :    //        0x71 0xC2 0xC3 0xC4
     211                 :    // le --> 0x04 0x03 0x02 0x01 0xF8 0xF8 0xF9 0xFA
     212                 :    //        0xA4 0xA3 0xA2 0x51 0x4C 0x4C 0x4D 0x9E
     213                 :    //        0xC4 0xC3 0xC2 0x71
     214                 :    // 20 bytes total.
     215                 : 
     216               2 :    l = 0x01020304 ;
     217               2 :    cdr->cdr_Long(& l) ;
     218                 : 
     219               2 :    l = - 0x05060708 ; // --> 0xFAF9F8F8
     220               2 :    cdr->cdr_Long(& l) ;
     221                 : 
     222               2 :    lArray[0] = 0x51A2A3A4 ;
     223               2 :    lArray[1] = - 0x61B2B3B4 ; // --> 0x9E4D4C4C
     224               2 :    lArray[2] = 0x71C2C3C4 ;
     225                 : 
     226               2 :    cdr->cdr_LongArray(& lArray[0], 3) ;
     227                 : }
     228                 : 
     229                 : void
     230               2 : TestULong(YAORB::CDR *cdr)
     231                 : {
     232                 :    CORBA::ULong ul ;
     233                 :    CORBA::ULong ulArray[3] ;
     234                 : 
     235                 :    // Expecting to write :
     236                 :    // 0x01020304 0x05060708 0xA1A2A3A4 0xB1B2B3B4 0xC1C2C3C4
     237                 :    // be --> 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08
     238                 :    //        0xA1 0xA2 0xA3 0xA4 0xB1 0xB2 0xB3 0xB4
     239                 :    //        0xC1 0xC2 0xC3 0xC4
     240                 :    // le --> 0x04 0x03 0x02 0x01 0x08 0x07 0x06 0x05
     241                 :    //        0xA4 0xA3 0xA2 0xA1 0x4C 0x4C 0x4D 0x9E
     242                 :    //        0xC4 0xC3 0xC2 0xC1
     243                 :    // 20 bytes total.
     244                 : 
     245                 :    // FIXME : Expecting to write :
     246                 :    // 20 bytes total.
     247                 : 
     248               2 :    ul = 0x01020304 ;
     249               2 :    cdr->cdr_ULong(& ul) ;
     250                 : 
     251               2 :    ul = 0x05060708 ;
     252               2 :    cdr->cdr_ULong(& ul) ;
     253                 : 
     254               2 :    ulArray[0] = 0xA1A2A3A4 ;
     255               2 :    ulArray[1] = 0xB1B2B3B4 ;
     256               2 :    ulArray[2] = 0xC1C2C3C4 ;
     257                 : 
     258               2 :    cdr->cdr_ULongArray(& ulArray[0], 3) ;
     259                 : }
     260                 : 
     261                 : void
     262               2 : TestLongLong(YAORB::CDR *cdr)
     263                 : {
     264                 :    CORBA::LongLong ll ;
     265                 :    CORBA::LongLong llArray[3] ;
     266                 : 
     267                 :    // Expecting to write :
     268                 :    // 0x0102030405060708
     269                 :    // 0xF6F5F4F3F2F1F0AB
     270                 :    // 0x21A2A3A4A5A6A7A8
     271                 :    // 0xCE4D4C4B4A494848
     272                 :    // 0x41C2C3C4C5C6C7C8
     273                 :    // be --> 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08
     274                 :    //        0xF6 0xF5 0xF4 0xF3 0xF2 0xF1 0xF0 0xAB
     275                 :    //        0x21 0xA2 0xA3 0xA4 0xA5 0xA5 0xA7 0xA8
     276                 :    //        0xCE 0x4D 0x4C 0x4B 0x4A 0x49 0x48 0x48
     277                 :    //        0x41 0xC2 0xC3 0xC4 0xC5 0xC5 0xC7 0xC8
     278                 :    // le --> 0x08 0x07 0x06 0x05 0x04 0x03 0x02 0x01
     279                 :    //        0xAB 0xF0 0xF1 0xF2 0xF3 0xF4 0xF5 0xF6
     280                 :    //        0xA8 0xA7 0xA6 0xA5 0xA4 0xA3 0xA2 0x21
     281                 :    //        0x48 0x48 0x49 0x4A 0x4B 0x4C 0x4D 0xCE
     282                 :    //        0xC8 0xC7 0xC6 0xC5 0xC4 0xC3 0xC2 0x41
     283                 :    // 40 bytes total.
     284                 : 
     285                 :    ll = 0x01020304 ;
     286                 :    ll <<= 32 ;
     287               2 :    ll += 0x05060708 ;
     288               2 :    cdr->cdr_LongLong(& ll) ;
     289                 : 
     290                 :    ll = - 0x090A0B0C ;
     291                 :    ll <<= 32 ;
     292               2 :    ll -= 0x0D0E0F55 ; // --> 0xF6F5F4F3F2F1F0AB
     293               2 :    cdr->cdr_LongLong(& ll) ;
     294                 : 
     295                 :    llArray[0] = 0x21A2A3A4 ;
     296                 :    llArray[0] <<= 32 ;
     297               2 :    llArray[0] += 0xA5A6A7A8 ;
     298                 : 
     299                 :    llArray[1] = - 0x31B2B3B4 ;
     300                 :    llArray[1] <<= 32 ;
     301               2 :    llArray[1] -= 0xB5B6B7B8 ; // --> 0xCE4D4C4B4A494848
     302                 : 
     303                 :    llArray[2] = 0x41C2C3C4 ;
     304                 :    llArray[2] <<= 32 ;
     305               2 :    llArray[2] += 0xC5C6C7C8 ;
     306                 : 
     307               2 :    cdr->cdr_LongLongArray(& llArray[0], 3) ;
     308                 : }
     309                 : 
     310                 : void
     311               2 : TestULongLong(YAORB::CDR *cdr)
     312                 : {
     313                 :    CORBA::ULongLong ull ;
     314                 :    CORBA::ULongLong ullArray[3] ;
     315                 : 
     316                 :    // Expecting to write :
     317                 :    // 0x0102030405060708
     318                 :    // 0x090A0B0C0D0E0F55
     319                 :    // 0xA1A2A3A4A5A6A7A8
     320                 :    // 0xB1B2B3B4B5B6B7B8
     321                 :    // 0xC1C2C3C4C5C6C7C8
     322                 :    // be --> 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08
     323                 :    //        0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x55
     324                 :    //        0xA1 0xA2 0xA3 0xA4 0xA5 0xA5 0xA7 0xA8
     325                 :    //        0xB1 0xB2 0xB3 0xB4 0xB5 0xB5 0xB7 0xB8
     326                 :    //        0xC1 0xC2 0xC3 0xC4 0xC5 0xC5 0xC7 0xC8
     327                 :    // le --> 0x08 0x07 0x06 0x05 0x04 0x03 0x02 0x01
     328                 :    //        0x55 0x0F 0x0E 0x0D 0x0C 0x0B 0x0A 0x09
     329                 :    //        0xA8 0xA7 0xA6 0xA5 0xA4 0xA3 0xA2 0xA1
     330                 :    //        0xB8 0xB7 0xB6 0xB5 0xB4 0xB3 0xB2 0xB1
     331                 :    //        0xC8 0xC7 0xC6 0xC5 0xC4 0xC3 0xC2 0xC1
     332                 :    // 40 bytes total.
     333                 : 
     334                 :    ull = 0x01020304 ;
     335                 :    ull <<= 32 ;
     336               2 :    ull += 0x05060708 ;
     337               2 :    cdr->cdr_ULongLong(& ull) ;
     338                 : 
     339                 :    ull = 0x090A0B0C ;
     340                 :    ull <<= 32 ;
     341               2 :    ull += 0x0D0E0F55 ;
     342               2 :    cdr->cdr_ULongLong(& ull) ;
     343                 : 
     344                 :    ullArray[0] = 0xA1A2A3A4 ;
     345                 :    ullArray[0] <<= 32 ;
     346               2 :    ullArray[0] += 0xA5A6A7A8 ;
     347                 : 
     348                 :    ullArray[1] = 0xB1B2B3B4 ;
     349                 :    ullArray[1] <<= 32 ;
     350               2 :    ullArray[1] += 0xB5B6B7B8 ;
     351                 : 
     352                 :    ullArray[2] = 0xC1C2C3C4 ;
     353                 :    ullArray[2] <<= 32 ;
     354               2 :    ullArray[2] += 0xC5C6C7C8 ;
     355                 : 
     356               2 :    cdr->cdr_ULongLongArray(& ullArray[0], 3) ;
     357                 : }
     358                 : 
     359                 : void
     360               2 : TestFloat(YAORB::CDR *cdr)
     361                 : {
     362                 :    CORBA::Float f ;
     363                 :    CORBA::Float fArray[3] ;
     364                 : 
     365                 :    // FIXME : Expecting to write :
     366                 : 
     367               2 :    f = 1.234e5 ;
     368               2 :    cdr->cdr_Float(& f) ;
     369                 : 
     370               2 :    f = - 9.876e-5 ;
     371               2 :    cdr->cdr_Float(& f) ;
     372                 : 
     373               2 :    fArray[0] = 11.22 ;
     374               2 :    fArray[1] = - 33.44 ;
     375               2 :    fArray[2] = 55.66 ;
     376                 : 
     377               2 :    cdr->cdr_FloatArray(& fArray[0], 3) ;
     378                 : }
     379                 : 
     380                 : void
     381               2 : TestDouble(YAORB::CDR *cdr)
     382                 : {
     383                 :    CORBA::Double d ;
     384                 :    CORBA::Double dArray[3] ;
     385                 : 
     386                 :    // FIXME : Expecting to write :
     387                 : 
     388               2 :    d = 1.234e5 ;
     389               2 :    cdr->cdr_Double(& d) ;
     390                 : 
     391               2 :    d = - 9.876e-5 ;
     392               2 :    cdr->cdr_Double(& d) ;
     393                 : 
     394               2 :    dArray[0] = 11.22 ;
     395               2 :    dArray[1] = - 33.44 ;
     396               2 :    dArray[2] = 55.66 ;
     397                 : 
     398               2 :    cdr->cdr_DoubleArray(& dArray[0], 3) ;
     399                 : }
     400                 : 
     401                 : void
     402               2 : TestLongDouble(YAORB::CDR *cdr)
     403                 : {
     404                 :    CORBA::LongDouble ld ;
     405                 :    CORBA::LongDouble ldArray[3] ;
     406                 : 
     407                 :    // FIXME : Expecting to write :
     408                 : 
     409               2 :    ld = 1.234e5 ;
     410               2 :    cdr->cdr_LongDouble(& ld) ;
     411                 : 
     412               2 :    ld = - 9.876e-5 ;
     413               2 :    cdr->cdr_LongDouble(& ld) ;
     414                 : 
     415               2 :    ldArray[0] = 11.22 ;
     416               2 :    ldArray[1] = - 33.44 ;
     417               2 :    ldArray[2] = 55.66 ;
     418                 : 
     419               2 :    cdr->cdr_LongDoubleArray(& ldArray[0], 3) ;
     420                 : }
     421                 : 
     422              24 : int main(int argc, char* argv[])
     423                 : {
     424              24 :    if (argc < 3)
     425                 :    {
     426               0 :       fprintf(stderr, "TestCdrWrite failed : bad arguments\n") ;
     427               0 :       return (-1) ;
     428                 :    }
     429                 : 
     430                 :    const char* inputFileName = argv[1] ;
     431              24 :    const char* outputFileName = argv[2] ;
     432                 : 
     433              24 :    FILE *input = fopen(inputFileName, "r") ;
     434                 : 
     435              24 :    if (input == NULL)
     436                 :    {
     437               0 :       fprintf(stderr, "TestCdrWrite failed : bad input\n") ;
     438               0 :       return (-2) ;
     439                 :    }
     440                 : 
     441                 :    try
     442                 :    {
     443              24 :       CDRFile cdr(outputFileName, YAORB::CDR_WRITE) ;
     444                 : 
     445                 :       char str[255] ;
     446              24 :       String menu ;
     447                 : 
     448              24 :       fscanf(input, "%s", str) ;
     449              24 :       menu = str ;
     450                 : 
     451              24 :       if (menu == "LITTLE-ENDIAN")
     452                 :       {
     453              12 :          cdr.SetLittleEndian() ;
     454                 :       }
     455              12 :       else if (menu == "BIG-ENDIAN")
     456                 :       {
     457              12 :          cdr.SetBigEndian() ;
     458                 :       }
     459                 :       else
     460                 :       {
     461               0 :          fprintf(stderr, "TestCdrWrite failed : bad byte order\n") ;
     462                 :          return (-3) ;
     463                 :       }
     464                 : 
     465              24 :       fscanf(input, "%s", str) ;
     466              24 :       menu = str ;
     467                 : 
     468              24 :       if (menu == "TestBool")
     469                 :       {
     470               2 :          TestBool(& cdr) ;
     471                 :       }
     472              22 :       else if (menu == "TestOctet")
     473                 :       {
     474               2 :          TestOctet(& cdr) ;
     475                 :       }
     476              20 :       else if (menu == "TestChar")
     477                 :       {
     478               2 :          TestChar(& cdr) ;
     479                 :       }
     480              18 :       else if (menu == "TestShort")
     481                 :       {
     482               2 :          TestShort(& cdr) ;
     483                 :       }
     484              16 :       else if (menu == "TestUShort")
     485                 :       {
     486               2 :          TestUShort(& cdr) ;
     487                 :       }
     488              14 :       else if (menu == "TestLong")
     489                 :       {
     490               2 :          TestLong(& cdr) ;
     491                 :       }
     492              12 :       else if (menu == "TestULong")
     493                 :       {
     494               2 :          TestULong(& cdr) ;
     495                 :       }
     496              10 :       else if (menu == "TestLongLong")
     497                 :       {
     498               2 :          TestLongLong(& cdr) ;
     499                 :       }
     500               8 :       else if (menu == "TestULongLong")
     501                 :       {
     502               2 :          TestULongLong(& cdr) ;
     503                 :       }
     504               6 :       else if (menu == "TestFloat")
     505                 :       {
     506               2 :          TestFloat(& cdr) ;
     507                 :       }
     508               4 :       else if (menu == "TestDouble")
     509                 :       {
     510               2 :          TestDouble(& cdr) ;
     511                 :       }
     512               2 :       else if (menu == "TestLongDouble")
     513                 :       {
     514               2 :          TestLongDouble(& cdr) ;
     515                 :       }
     516               0 :       else if (menu == "yyy")
     517                 :       {
     518               0 :       }
     519                 : 
     520                 :    }
     521              24 :    catch (...)
     522                 :    {
     523               0 :       fprintf(stderr, "TestCdrWrite failed : exception\n") ;
     524               0 :       return (-4) ;
     525                 :    }
     526                 : 
     527              24 :    fclose (input) ;
     528                 :    return 0;
     529                 : }
     530                 : 

Generated by: LTP GCOV extension version 1.4