Thread: [Cppunit-cvs] cppunit2/src/opentest remoteinterfaces.cpp,1.2,1.3 serializer.cpp,1.8,1.9 sharedmemory

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/cppunit/cppunit2/src/opentest
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv16321/src/opentest

Modified Files:
	remoteinterfaces.cpp serializer.cpp sharedmemorytransport.cpp 
Log Message:
* fixed compilation without RTTI
* revised stringize implementation to allow an additional customization point by overloading toString().
* added test and corrected bug in serialization/packets implementation.


Index: remoteinterfaces.cpp
===================================================================
RCS file: /cvsroot/cppunit/cppunit2/src/opentest/remoteinterfaces.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** remoteinterfaces.cpp	25 Jun 2005 11:08:05 -0000	1.2
--- remoteinterfaces.cpp	6 Sep 2005 07:31:42 -0000	1.3
***************
*** 29,32 ****
--- 29,33 ----
  
  RemoteMessage::RemoteMessage( MessageId id )
+    : messageId_( id )
  {
  }
***************
*** 265,275 ****
  // //////////////////////////////////////////////////////////////////
  // //////////////////////////////////////////////////////////////////
! // class MessageSender
  // //////////////////////////////////////////////////////////////////
  // //////////////////////////////////////////////////////////////////
  
  void 
! MessageSender::sendMessage( const RemoteMessagePtr &message )
  {
  }
  
--- 266,294 ----
  // //////////////////////////////////////////////////////////////////
  // //////////////////////////////////////////////////////////////////
! // class MessageServerProxy
  // //////////////////////////////////////////////////////////////////
  // //////////////////////////////////////////////////////////////////
  
+ MessageServerProxy::MessageServerProxy()
+    : transport_( 0 )
+ {
+ }
+ 
+ 
  void 
! MessageServerProxy::setTransport( MessageTransport &transport )
  {
+    transport_ = &transport;
+ }
+ 
+ 
+ void 
+ MessageServerProxy::sendMessage( const RemoteMessagePtr &message )
+ {
+    if ( transport_ )
+       transport_->sendMessage( message );
+    else  // @todo transport error
+    {
+    }
  }
  
***************
*** 406,410 ****
  
  void 
! TestRunnerProxy::runTests( const TestPlan &plan )
  {
     sendMessage( makeSimpleRemoteMessage( runnerMessageRunTests, plan ) );
--- 425,429 ----
  
  void 
! TestRunnerProxy::runTests( const TestPlans &plan )
  {
     sendMessage( makeSimpleRemoteMessage( runnerMessageRunTests, plan ) );

Index: serializer.cpp
===================================================================
RCS file: /cvsroot/cppunit/cppunit2/src/opentest/serializer.cpp,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** serializer.cpp	4 Jul 2005 08:12:33 -0000	1.8
--- serializer.cpp	6 Sep 2005 07:31:42 -0000	1.9
***************
*** 72,80 ****
  
  void 
! Packets::beginMessage()
  {
!    appendPacketIfFull( externalPos_ );
     MessagePacket message;
!    message.position_ = externalPos_;
     message.length_ = 0;
     messages_.push_back( message );
--- 72,80 ----
  
  void 
! Packets::beginWriteMessage()
  {
!    appendPacketIfFull();
     MessagePacket message;
!    message.position_ = writePos_;
     message.length_ = 0;
     messages_.push_back( message );
***************
*** 83,115 ****
  
  void 
! Packets::received( void *data, Pos length )
! {
!    write( externalPos_, static_cast<Byte *>( data ), length );
! }
! 
! 
! unsigned int 
! Packets::send( void *dest, 
!                Pos availableLength )
! {
!    return read( externalPos_, static_cast<Byte *>( dest ), availableLength );
! }
! 
! 
! void 
! Packets::endExternalMessage()
  {
     CPPTL_ASSERT_MESSAGE( !messages_.empty()  &&  messages_.back().length_ == 0, 
                           "No message started." );
!    messages_.back().length_ = distance( messages_.back().position_, externalPos_ );
! }
! 
! 
! void 
! Packets::endSerializeMessage()
! {
!    CPPTL_ASSERT_MESSAGE( !messages_.empty()  &&  messages_.back().length_ > 0, 
!                          "No message started." );
!    messages_.back().length_ = distance( messages_.back().position_, serializePos_ );
  }
  
--- 83,91 ----
  
  void 
! Packets::endWriteMessage()
  {
     CPPTL_ASSERT_MESSAGE( !messages_.empty()  &&  messages_.back().length_ == 0, 
                           "No message started." );
!    messages_.back().length_ = distance( messages_.back().position_, writePos_ );
  }
  
***************
*** 134,162 ****
  Packets::discardFirstMessage()
  {
!    Packet *current = packetsHead_;
!    while ( current != externalPos_.packet_ )
!    {
!       Packet *toDelete = current;
!       current = current->next_;
!       CPPTL_ASSERT_MESSAGE( toDelete != serializePos_.packet_, 
!                             "Deleting packets used for serialization." );
!       delete toDelete;
!    }
!    packetsHead_ = current;
  }
  
  
! unsigned char 
! Packets::serializationReadNextByte()
  {
!    if ( serializePos_ )
     {
!       if ( serializePos_.currentData_ == serializePos_.packet_->endInitialized_ )
        {
!          if ( serializePos_.packet_->next_ == 0 )
              return ccEndBuffer;
!          serializePos_.seekToNextPacket();
        }
!       return *(serializePos_.currentData_++);
     }
     return ccEndBuffer;
--- 110,146 ----
  Packets::discardFirstMessage()
  {
!    //Packet *current = packetsHead_;
!    //while ( current != writePos_.packet_ )
!    //{
!    //   Packet *toDelete = current;
!    //   current = current->next_;
!    //   CPPTL_ASSERT_MESSAGE( toDelete != readPos_.packet_, 
!    //                         "Deleting packets used for serialization." );
!    //   delete toDelete;
!    //}
!    //packetsHead_ = current;
  }
  
  
! Packets::Pos
! Packets::read( void *dest, 
!                Pos availableLength )
  {
!    return read( readPos_, static_cast<Byte *>( dest ), availableLength );
! }
! 
! 
! Packets::Byte
! Packets::readByte()
! {
!    if ( readPos_ )
     {
!       if ( readPos_.currentData_ == readPos_.packet_->endInitialized_ )
        {
!          if ( readPos_.packet_->next_ == 0 )
              return ccEndBuffer;
!          readPos_.seekToNextPacket();
        }
!       return *(readPos_.currentData_++);
     }
     return ccEndBuffer;
***************
*** 164,213 ****
  
  void 
! Packets::serializationUngetLastByte()
  {
!    CPPTL_ASSERT_MESSAGE( serializePos_, "No byte to unget" );
!    if ( serializePos_.currentData_ > serializePos_.packet_->begin_ )
!       --serializePos_.currentData_;
     else
!       serializePos_.seekBeforeEndOfPreviousPacket();
! }
! 
! bool 
! Packets::serializationRead( void *buffer, 
!                             Pos length )
! {
!    return read( serializePos_, static_cast<Byte *>( buffer ), length ) == length;
  }
  
  void 
! Packets::serializationWrite( const void *buffer, 
!                              Pos length )
  {
!    write( serializePos_, static_cast<const Byte *>( buffer ), length );
  }
  
  void 
! Packets::serializationWrite( Byte byte )
  {
!    if ( serializePos_  &&  serializePos_.currentData_ != serializePos_.packet_->end_ )
!       *serializePos_.currentData_++ = byte;
     else
!       write( serializePos_, &byte, 1 );
  }
  
  
  void 
! Packets::appendPacketIfFull( PacketPos &pos )
  {
!    if ( !pos  ||  pos.currentData_ == pos.packet_->end_ )
     {
!       Packet *packet = new Packet( defaultPacketSize_, pos.packet_ );
        if ( !packetsHead_ )
           packetsHead_ = packet;
!       pos = PacketPos( packet );
!       if ( !serializePos_ )
!          serializePos_ = pos;
!       if ( !externalPos_ )
!          externalPos_ = pos;
     }
  }
--- 148,191 ----
  
  void 
! Packets::unreadLastByte()
  {
!    CPPTL_ASSERT_MESSAGE( readPos_, "No byte to unget" );
!    if ( readPos_.currentData_ > readPos_.packet_->begin_ )
!       --readPos_.currentData_;
     else
!       readPos_.seekBeforeEndOfPreviousPacket();
  }
  
  void 
! Packets::write( const void *buffer, 
!                 Pos length )
  {
!    write( writePos_, static_cast<const Byte *>( buffer ), length );
  }
  
  void 
! Packets::writeByte( Byte byte )
  {
!    if ( writePos_  &&  writePos_.currentData_ != writePos_.packet_->end_ )
!    {
!       *writePos_.currentData_++ = byte;
!       writePos_.packet_->endInitialized_ = writePos_.currentData_;
!    }
     else
!       write( writePos_, &byte, 1 );
  }
  
  
  void 
! Packets::appendPacketIfFull()
  {
!    if ( !writePos_  ||  writePos_.currentData_ == writePos_.packet_->end_ )
     {
!       Packet *packet = new Packet( defaultPacketSize_, writePos_.packet_ );
        if ( !packetsHead_ )
           packetsHead_ = packet;
!       writePos_ = PacketPos( packet );
!       if ( !readPos_ )
!          readPos_ = writePos_;
     }
  }
***************
*** 239,243 ****
  
     if ( !pos )
!       appendPacketIfFull( pos );
  
     Pos writeLength  = CPPTL_MIN( pos.availableForWriting(), length );
--- 217,221 ----
  
     if ( !pos )
!       appendPacketIfFull();
  
     Pos writeLength  = CPPTL_MIN( pos.availableForWriting(), length );
***************
*** 251,255 ****
        CPPTL_ASSERT_MESSAGE( pos.currenData_ == pos.packet_->end_, 
                              "Should be at the end of the current packet" );
!       appendPacketIfFull( pos );
        writeLength  = CPPTL_MIN( pos.packet_->length(), length );
        memcpy( pos.packet_->begin_, data, writeLength );
--- 229,233 ----
        CPPTL_ASSERT_MESSAGE( pos.currenData_ == pos.packet_->end_, 
                              "Should be at the end of the current packet" );
!       appendPacketIfFull();
        writeLength  = CPPTL_MIN( pos.packet_->length(), length );
        memcpy( pos.packet_->begin_, data, writeLength );
***************
*** 325,332 ****
  
  
! unsigned char 
  Stream::readNextByte()
  {
!    return packets_.serializationReadNextByte();
  }
  
--- 303,310 ----
  
  
! Stream::Byte 
  Stream::readNextByte()
  {
!    return packets_.readByte();
  }
  
***************
*** 334,338 ****
  Stream::ungetLastByte()
  {
!    packets_.serializationUngetLastByte();
  }
  
--- 312,316 ----
  Stream::ungetLastByte()
  {
!    packets_.unreadLastByte();
  }
  
***************
*** 340,344 ****
  Stream::read( void *buffer, unsigned int length )
  {
!    if ( !packets_.serializationRead( buffer, length ) )
        setError( "Attempted to read beyond buffer end." );
  }
--- 318,322 ----
  Stream::read( void *buffer, unsigned int length )
  {
!    if ( packets_.read( buffer, length ) != length )
        setError( "Attempted to read beyond buffer end." );
  }
***************
*** 346,352 ****
  
  void 
! Stream::write( unsigned char byte )
  {
!    packets_.serializationWrite( byte );
  }
  
--- 324,330 ----
  
  void 
! Stream::write( Byte byte )
  {
!    packets_.writeByte( byte );
  }
  
***************
*** 355,359 ****
  Stream::write( const void *buffer, unsigned int length )
  {
!    packets_.serializationWrite( buffer, length );
  }
  
--- 333,337 ----
  Stream::write( const void *buffer, unsigned int length )
  {
!    packets_.write( buffer, length );
  }
  
***************
*** 401,412 ****
  
  void 
! Stream::doSerializeInteger( unsigned char kind, 
                              LargestUnsignedInt value )
  {
!    unsigned char buffer[ (sizeof(value)*8 + ccIntegerBaseShift - 1) / ccIntegerBaseShift ];
!    unsigned char *current = buffer + sizeof(buffer);
     do
     {
!       unsigned char reminder = value & ((1 << ccIntegerBaseShift) - 1);
        *--current = reminder + ccIntegerZero;
        value >>= ccIntegerBaseShift;
--- 379,390 ----
  
  void 
! Stream::doSerializeInteger( Byte kind, 
                              LargestUnsignedInt value )
  {
!    Byte buffer[ (sizeof(value)*8 + ccIntegerBaseShift - 1) / ccIntegerBaseShift ];
!    Byte *current = buffer + sizeof(buffer);
     do
     {
!       Byte reminder = Byte(value & ((1 << ccIntegerBaseShift) - 1));
        *--current = reminder + ccIntegerZero;
        value >>= ccIntegerBaseShift;
***************
*** 446,450 ****
        else
        {
!           CPPTL_ASSERT_MESSAGE( (unsigned char)*current >= ccIntegerZero,
                                  "Real number conversion produced stream control characters!" );
        }
--- 424,428 ----
        else
        {
!           CPPTL_ASSERT_MESSAGE( (Byte)*current >= ccIntegerZero,
                                  "Real number conversion produced stream control characters!" );
        }
***************
*** 500,504 ****
  {
     value = 0;
!    unsigned char digit;
     while ( (digit = readNextByte()) >= ccIntegerZero )
     {
--- 478,482 ----
  {
     value = 0;
!    Byte digit;
     while ( (digit = readNextByte()) >= ccIntegerZero )
     {
***************
*** 518,522 ****
        return *this;
  
!    unsigned char control = readNextByte();
     if ( control == ccBooleanTrue )
        value = true;
--- 496,500 ----
        return *this;
  
!    Byte control = readNextByte();
     if ( control == ccBooleanTrue )
        value = true;
***************
*** 534,538 ****
     LargestInt temp;
     *this >> temp;
!    value = temp;
     return *this;
  }
--- 512,516 ----
     LargestInt temp;
     *this >> temp;
!    value = int(temp);
     return *this;
  }
***************
*** 544,548 ****
     LargestUnsignedInt temp;
     *this >> temp;
!    value = temp;
     return *this;
  }
--- 522,526 ----
     LargestUnsignedInt temp;
     *this >> temp;
!    value = (unsigned int)temp;
     return *this;
  }
***************
*** 555,559 ****
        return *this;
  
!    unsigned char control = readNextByte();
     LargestUnsignedInt unsignedValue;
     if ( control == ccPositiveInteger )
--- 533,537 ----
        return *this;
  
!    Byte control = readNextByte();
     LargestUnsignedInt unsignedValue;
     if ( control == ccPositiveInteger )
***************
*** 565,569 ****
     {
        doUnserializeInteger( unsignedValue );
!       value = -unsignedValue;
     }
     else
--- 543,547 ----
     {
        doUnserializeInteger( unsignedValue );
!       value = -LargestInt(unsignedValue);
     }
     else
***************
*** 579,583 ****
        return *this;
  
!    unsigned char control = readNextByte();
     if ( control == ccPositiveInteger )
        doUnserializeInteger( value );
--- 557,561 ----
        return *this;
  
!    Byte control = readNextByte();
     if ( control == ccPositiveInteger )
        doUnserializeInteger( value );
***************
*** 594,598 ****
  
     CppTL::StringBuffer buffer;
!    unsigned char control = readNextByte();
     if ( control == ccNegativeReal )
        buffer += "-";
--- 572,576 ----
  
     CppTL::StringBuffer buffer;
!    Byte control = readNextByte();
     if ( control == ccNegativeReal )
        buffer += "-";
***************
*** 604,608 ****
     while ( true )
     {
!       unsigned char digit = readNextByte();
        if ( digit == ccRealWithinPlusSign )
           buffer += "+";
--- 582,586 ----
     while ( true )
     {
!       Byte digit = readNextByte();
        if ( digit == ccRealWithinPlusSign )
           buffer += "+";
***************
*** 634,638 ****
        return *this;
  
!    unsigned char control = readNextByte();
     if ( control == ccString )
        readString( str );
--- 612,616 ----
        return *this;
  
!    Byte control = readNextByte();
     if ( control == ccString )
        readString( str );
***************
*** 644,648 ****
  
  void 
! Stream::readDictionnaryEntry ( unsigned char control,
                                 String &str )
  {
--- 622,626 ----
  
  void 
! Stream::readDictionnaryEntry ( Byte control,
                                 String &str )
  {
***************
*** 671,675 ****
     LargestUnsignedInt length;
     doUnserializeInteger( length );
!    unsigned char control = readNextByte();
     if ( control != ccString )
        setError( "Expected string." );
--- 649,653 ----
     LargestUnsignedInt length;
     doUnserializeInteger( length );
!    Byte control = readNextByte();
     if ( control != ccString )
        setError( "Expected string." );
***************
*** 720,724 ****
  
  bool 
! Stream::isNamedPropertyControl( unsigned char control )
  {
     return control == ccLookUpDictionnaryEntry  
--- 698,702 ----
  
  bool 
! Stream::isNamedPropertyControl( Byte control )
  {
     return control == ccLookUpDictionnaryEntry  
***************
*** 730,734 ****
  Stream::operator >>( Properties &properties )
  {
!    unsigned char control = readNextByte();
     if ( control == ccEmptyProperties )
        return *this;
--- 708,712 ----
  Stream::operator >>( Properties &properties )
  {
!    Byte control = readNextByte();
     if ( control == ccEmptyProperties )
        return *this;
***************
*** 816,820 ****
  Stream::operator >>( Value &value )
  {
!    unsigned char control = readNextByte();
     switch ( control )
     {
--- 794,798 ----
  Stream::operator >>( Value &value )
  {
!    Byte control = readNextByte();
     switch ( control )
     {

Index: sharedmemorytransport.cpp
===================================================================
RCS file: /cvsroot/cppunit/cppunit2/src/opentest/sharedmemorytransport.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** sharedmemorytransport.cpp	1 Jul 2005 08:19:36 -0000	1.3
--- sharedmemorytransport.cpp	6 Sep 2005 07:31:42 -0000	1.4
***************
*** 615,621 ****
     while ( !messages.empty() )
     {
!       buffer.stream_.packets().beginMessage();
        buffer.stream_ << messages.front();
!       buffer.stream_.packets().endSerializeMessage();
        messages.pop_front();
     }
--- 615,621 ----
     while ( !messages.empty() )
     {
!       buffer.stream_.packets().beginWriteMessage();
        buffer.stream_ << messages.front();
!       buffer.stream_.packets().endWriteMessage();
        messages.pop_front();
     }
***************
*** 663,667 ****
                 buffer.processedLength_ = 0;
                 log( "read: message size is %d", buffer.messageLength_ );
!                buffer.stream_.packets().beginMessage();
              }
           }
--- 663,667 ----
                 buffer.processedLength_ = 0;
                 log( "read: message size is %d", buffer.messageLength_ );
!                buffer.stream_.packets().beginWriteMessage();
              }
           }
***************
*** 670,680 ****
           {
              Pos toRead = CPPTL_MIN( available, buffer.messageLength_ );
!             buffer.stream_.packets().received( buffer.data_ + buffer.circular_->readPos_, 
!                                                toRead );
              buffer.read( "Message content", toRead );
              if ( buffer.processedLength_ == buffer.messageLength_ )
              {
                 log( "read: message completly received" );
!                buffer.stream_.packets().endExternalMessage();
                 buffer.state_ = bsSize;
                 buffer.processedLength_ = 0;
--- 670,680 ----
           {
              Pos toRead = CPPTL_MIN( available, buffer.messageLength_ );
!             buffer.stream_.packets().write( buffer.data_ + buffer.circular_->readPos_, 
!                                             toRead );
              buffer.read( "Message content", toRead );
              if ( buffer.processedLength_ == buffer.messageLength_ )
              {
                 log( "read: message completly received" );
!                buffer.stream_.packets().endWriteMessage();
                 buffer.state_ = bsSize;
                 buffer.processedLength_ = 0;
***************
*** 728,732 ****
              Pos toWrite = CPPTL_MIN( available, buffer.messageLength_ );
              Byte *target = buffer.data_ + buffer.circular_->normalizeWritePos();
!             Pos written = buffer.stream_.packets().send( target, toWrite );
              buffer.write( "Message content", written );
              if ( buffer.processedLength_ == buffer.messageLength_ )
--- 728,732 ----
              Pos toWrite = CPPTL_MIN( available, buffer.messageLength_ );
              Byte *target = buffer.data_ + buffer.circular_->normalizeWritePos();
!             Pos written = buffer.stream_.packets().read( target, toWrite );
              buffer.write( "Message content", written );
              if ( buffer.processedLength_ == buffer.messageLength_ )
***************
*** 809,813 ****
  
  void 
! SharedMemoryTransport::send( const RemoteMessagePtr &message )
  {
     impl_->send( message );
--- 809,813 ----
  
  void 
! SharedMemoryTransport::sendMessage( const RemoteMessagePtr &message )
  {
     impl_->send( message );

Thread: [Cppunit-cvs] cppunit2/src/opentest remoteinterfaces.cpp,1.2,1.3 serializer.cpp,1.8,1.9 sharedmemory

cppunit-cvs