[Cppunit-cvs] cppunit2/src/cpput message.cpp, NONE, 1.1 SConscript, 1.10, 1.11 assert.cpp, 1.18, 1.19

[Baptiste L. <bl...@us...>]

Update of /cvsroot/cppunit/cppunit2/src/cpput
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv13370/src/cpput

Modified Files:
	SConscript assert.cpp 
Added Files:
	message.cpp 
Log Message:
- added LazyMessage, a simple proxy class that avoid building Message until it is really needed (assertion failed).

Index: SConscript
===================================================================
RCS file: /cvsroot/cppunit/cppunit2/src/cpput/SConscript,v
retrieving revision 1.10
retrieving revision 1.11
diff -C2 -d -r1.10 -r1.11
*** SConscript	7 Nov 2005 22:43:08 -0000	1.10
--- SConscript	2 Sep 2006 11:24:53 -0000	1.11
***************
*** 7,10 ****
--- 7,11 ----
      extendeddata.cpp
      lighttestrunner.cpp
+ 	message.cpp
      registry.cpp 
      testcase.cpp 

--- NEW FILE: message.cpp ---
#include <cpput/message.h>
#include <string>

namespace CppUT {

// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class Message
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////

Message Message::none;

Message::Message()
{
}

Message::Message( const CppTL::StringBuffer &shortDescription )
{
   add( shortDescription );
}

Message::Message( const CppTL::StringConcatenator &shortDescription )
{
   add( shortDescription );
}

Message::Message( const CppTL::ConstString &shortDescription )
{
   add( shortDescription );
}

Message::Message( const std::string &shortDescription )
{
   add( shortDescription );
}

Message::Message( const char *shortDescription )
{
   add( shortDescription );
}

bool 
Message::empty() const
{
   return details_.empty();
}

void 
Message::insertAt( int index, 
                   const char *detail )
{
   insertAt( index, std::string(detail) );
}

void 
Message::insertAt( int index, 
                   const std::string &detail )
{
   details_.insert( details_.begin() + index, detail );
}

void 
Message::insertAt( int index,
                   const Message &other )
{
   details_.insert( details_.begin() + index, 
                     other.details_.begin(),
                     other.details_.end() );
}

void 
Message::add( const char *detail )   // needed to solve ambiguity due to implicit constructor
{
   add( CppTL::ConstString(detail) );
}

void 
Message::add( const std::string &detail )
{
   details_.push_back( detail );
}

void 
Message::add( const CppTL::ConstString &detail )
{
   details_.push_back( detail );
}

void 
Message::extend( const Message &other )
{
   insertAt( int(details_.size()), other );
}

int 
Message::count() const
{
   return int(details_.size());
}

std::string 
Message::at( int index ) const
{
   return CPPTL_AT( details_, index ).str();
}

std::string 
Message::toString() const
{
   CppTL::StringBuffer message;
   Details::const_iterator it = details_.begin();
   Details::const_iterator itEnd = details_.end();

   while ( it != itEnd )
   {
      message += *it++;
      message += "\n";

      if ( it != itEnd )
         message += "- ";
   }

   return message.c_str();
}



// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class LazyMessage
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////

LazyMessage LazyMessage::none;

LazyMessage::LazyMessage()
   : kind_( defaultConstructor )
{
}

LazyMessage::LazyMessage( const CppTL::StringBuffer &shortDescription )
   : kind_( buffer )
{
   init_.stringBuffer_ = &shortDescription;
}

LazyMessage::LazyMessage( const CppTL::StringConcatenator &shortDescription )
   : kind_( concatenator )
{
   init_.concatenor_ = &shortDescription;
}

LazyMessage::LazyMessage( const CppTL::ConstString &shortDescription )
   : kind_( constString )
{
   init_.constString_ = &shortDescription;
}

LazyMessage::LazyMessage( const std::string &shortDescription )
   : kind_( stdString )
{
   init_.stdString_ = &shortDescription;
}

LazyMessage::LazyMessage( const char *shortDescription )
   : kind_( constChar )
{
   init_.cz_ = shortDescription;
}

LazyMessage::LazyMessage( const Message &aMessage )
   : kind_( message )
{
   init_.message_ = &aMessage;
}


Message 
LazyMessage::makeMessage() const
{
   switch ( kind_ )
   {
   default:
      CPPTL_DEBUG_ASSERT_UNREACHABLE;
   case defaultConstructor:
      return Message();
   case constChar:
      return Message(init_.cz_);
   case stdString:
      return Message(*(init_.stdString_));
   case constString:
      return Message(*(init_.constString_));
   case concatenator:
      return Message(*(init_.concatenor_));
   case buffer:
      return Message(*(init_.stringBuffer_));
   case message:
      return Message(*(init_.message_));
   }
}


} // namespace CppUT

Index: assert.cpp
===================================================================
RCS file: /cvsroot/cppunit/cppunit2/src/cpput/assert.cpp,v
retrieving revision 1.18
retrieving revision 1.19
diff -C2 -d -r1.18 -r1.19
*** assert.cpp	13 Nov 2005 10:12:01 -0000	1.18
--- assert.cpp	2 Sep 2006 11:24:53 -0000	1.19
***************
*** 10,16 ****
  
  void 
! fail( const Message &message )
  {
!    currentAssertion().setMessages( message );
     realizeAssertion();
  }
--- 10,23 ----
  
  void 
! fail()
  {
!    fail( translate("Assertion Failed") );
! }
! 
! 
! void 
! fail( const LazyMessage &message )
! {
!    currentAssertion().setMessages( message.makeMessage() );
     realizeAssertion();
  }
***************
*** 19,28 ****
  void 
  checkTrue( bool shouldBeTrue,
!            const Message &message )
  {
     if ( shouldBeTrue )
        return;
  
!    Message newMessage( message );
     newMessage.insertAt( 0, translate( "expression did not evaluate to true." ) );
     fail( newMessage );
--- 26,35 ----
  void 
  checkTrue( bool shouldBeTrue,
!            const LazyMessage &message )
  {
     if ( shouldBeTrue )
        return;
  
!    Message newMessage( message.makeMessage() );
     newMessage.insertAt( 0, translate( "expression did not evaluate to true." ) );
     fail( newMessage );
***************
*** 32,41 ****
  void 
  checkFalse( bool shouldBeFalse,
!             const Message &message )
  {
     if ( !shouldBeFalse )
        return;
  
!    Message newMessage( message );
     newMessage.insertAt( 0, translate( "expression did not evaluate to false." ) );
     fail( newMessage );
--- 39,48 ----
  void 
  checkFalse( bool shouldBeFalse,
!             const LazyMessage &message )
  {
     if ( !shouldBeFalse )
        return;
  
!    Message newMessage( message.makeMessage() );
     newMessage.insertAt( 0, translate( "expression did not evaluate to false." ) );
     fail( newMessage );
***************
*** 45,49 ****
  void
  checkAssertionFail( bool assertionFailed,
!                     const Message &message )
  {
     if ( assertionFailed )
--- 52,56 ----
  void
  checkAssertionFail( bool assertionFailed,
!                     const LazyMessage &message )
  {
     if ( assertionFailed )
***************
*** 51,55 ****
  
     Message newMessage( translate( "Assertion expression did not fail as expected." ) );
!    newMessage.extend( message );
     fail( message );
  }
--- 58,62 ----
  
     Message newMessage( translate( "Assertion expression did not fail as expected." ) );
!    newMessage.extend( message.makeMessage() );
     fail( message );
  }
***************
*** 58,62 ****
  void
  checkAssertionPass( bool assertionFailed,
!                     const Message &message )
  {
     if ( !assertionFailed )
--- 65,69 ----
  void
  checkAssertionPass( bool assertionFailed,
!                     const LazyMessage &message )
  {
     if ( !assertionFailed )
***************
*** 64,68 ****
  
     Message newMessage( translate( "Assertion expression did not pass as expected." ) );
!    newMessage.extend( message );
     fail( message );
  }
--- 71,75 ----
  
     Message newMessage( translate( "Assertion expression did not pass as expected." ) );
!    newMessage.extend( message.makeMessage() );
     fail( message );
  }
***************
*** 72,78 ****
  buildEqualityFailedMessage( const std::string &expected,
                              const std::string &actual,
!                             const Message &message )
  {
!    Message newMessage( message );
     newMessage.add( translate( "Equality assertion failed." ) );
     newMessage.add( translate( "Expected: " ) + expected );
--- 79,85 ----
  buildEqualityFailedMessage( const std::string &expected,
                              const std::string &actual,
!                             const LazyMessage &message )
  {
!    Message newMessage( message.makeMessage() );
     newMessage.add( translate( "Equality assertion failed." ) );
     newMessage.add( translate( "Expected: " ) + expected );
***************
*** 85,91 ****
  buildUnequalityFailedMessage( const std::string &expected,
                                const std::string &actual,
!                               const Message &message )
  {
!    Message newMessage( message );
     newMessage.add( translate( "Unequality assertion failed (expected & actual should be different)." ) );
     newMessage.add( translate( "Expected: " ) + expected );
--- 92,98 ----
  buildUnequalityFailedMessage( const std::string &expected,
                                const std::string &actual,
!                               const LazyMessage &message )
  {
!    Message newMessage( message.makeMessage() );
     newMessage.add( translate( "Unequality assertion failed (expected & actual should be different)." ) );
     newMessage.add( translate( "Expected: " ) + expected );
***************
*** 99,103 ****
                     double actual, 
                     double tolerance, 
!                    const Message &message )
  {
     double diff = expected - actual;
--- 106,110 ----
                     double actual, 
                     double tolerance, 
!                    const LazyMessage &message )
  {
     double diff = expected - actual;
***************
*** 107,111 ****
        return;
  
!    Message newMessage( message );
     newMessage.add( translate( "Double equality assertion failed." ) );
     newMessage.add( translate( "Expected: " ) + CppTL::toString( expected ) );
--- 114,118 ----
        return;
  
!    Message newMessage( message.makeMessage() );
     newMessage.add( translate( "Double equality assertion failed." ) );
     newMessage.add( translate( "Expected: " ) + CppTL::toString( expected ) );