[Cpptool-cvs] rfta/src/rftaparser CStringEnumeratorTest.cpp,NONE,1.1 CStringEnumeratorTest.h,NONE,1.

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

Update of /cvsroot/cpptool/rfta/src/rftaparser
In directory sc8-pr-cvs1:/tmp/cvs-serv12839/src/rftaparser

Added Files:
	CStringEnumeratorTest.cpp CStringEnumeratorTest.h 
	CStringViewTest.cpp CStringViewTest.h 
Log Message:
* added const char * string wrapper and iterator (still need adjustment).

--- NEW FILE: CStringEnumeratorTest.cpp ---
// //////////////////////////////////////////////////////////////////////////
// (c)Copyright 2002, Baptiste Lepilleur.
// Created: 2003/04/26
// //////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "CStringEnumeratorTest.h"

namespace Refactoring
{

RFTAPARSER_TEST_SUITE_REGISTRATION( CStringEnumeratorTest );

CStringEnumeratorTest::CStringEnumeratorTest()
   : text_( "12345" )
   , string_( text_.c_str(), text_.c_str() + text_.length() )
{
}

CStringEnumeratorTest::~CStringEnumeratorTest()
{
}

void 
CStringEnumeratorTest::setUp()
{
   enumText_ = Xtl::CStringEnumerator( string_ );
}

void 
CStringEnumeratorTest::tearDown()
{
}

void 
CStringEnumeratorTest::testDefaultConstructor()
{
   Xtl::CStringEnumerator enumEmpty;
   CPPUNIT_ASSERT( !enumEmpty.hasNext() );
   CPPUNIT_ASSERT( enumEmpty.getCurrentPos() == 0 );
   CPPUNIT_ASSERT( enumEmpty.getString().isEmpty() );
}

void 
CStringEnumeratorTest::testStringConstructor()
{
   CPPUNIT_ASSERT( enumText_.getString() == string_ );
   CPPUNIT_ASSERT( enumText_.getCurrentPos() == string_.getStart() );
   RFTA_ASSERT_EQUAL( '1', enumText_.getCurrent() );
   RFTA_ASSERT_EQUAL( '1', *enumText_ );
}

void 
CStringEnumeratorTest::testIncrement()
{
   RFTA_ASSERT_EQUAL( '1', *enumText_++ );
   RFTA_ASSERT_EQUAL( '2', *enumText_++ );
   RFTA_ASSERT_EQUAL( '4', *++enumText_ );
   enumText_++;
   RFTA_ASSERT_EQUAL( '5', *enumText_++ );
   RFTA_ASSERT_EQUAL( 0, *enumText_ );
}

void 
CStringEnumeratorTest::testIndex()
{
   RFTA_ASSERT_EQUAL( '1', enumText_[0] );
   RFTA_ASSERT_EQUAL( '2', enumText_[1] );
   RFTA_ASSERT_EQUAL( '3', enumText_[2] );
   RFTA_ASSERT_EQUAL( '4', enumText_[3] );
   RFTA_ASSERT_EQUAL( '5', enumText_[4] );
   RFTA_ASSERT_EQUAL( 0, enumText_[5] );

   ++enumText_;
   ++enumText_;
   RFTA_ASSERT_EQUAL( 0, enumText_[-3] );
   RFTA_ASSERT_EQUAL( '1', enumText_[-2] );
   RFTA_ASSERT_EQUAL( '2', enumText_[-1] );
}

void 
CStringEnumeratorTest::testDecrement()
{
   enumText_++;
   enumText_++;
   RFTA_ASSERT_EQUAL( '3', *enumText_-- );
   RFTA_ASSERT_EQUAL( '1', *--enumText_ );
   RFTA_ASSERT_EQUAL( '1', *enumText_-- );
   RFTA_ASSERT_EQUAL( 0, *enumText_ );
}

void 
CStringEnumeratorTest::testAddable()
{
   Xtl::CStringEnumerator enum2 = enumText_ + 2;
   RFTA_ASSERT_EQUAL( '3', *enum2 );
   enumText_ += 3;
   RFTA_ASSERT_EQUAL( '4', *enumText_ );
}

void 
CStringEnumeratorTest::testSubstractable()
{
   Xtl::CStringEnumerator enumEnd = enumText_ + 5;
   Xtl::CStringEnumerator enum2 = enumEnd - 2;
   RFTA_ASSERT_EQUAL( '4', *enum2 );
   enumEnd -= 4;
   RFTA_ASSERT_EQUAL( '2', *enumEnd );
}

void 
CStringEnumeratorTest::testDistance()
{
   Xtl::CStringEnumerator enumEnd = enumText_ + 5;
   Xtl::CStringEnumerator enum3 = enumEnd - 2;

   RFTA_ASSERT_EQUAL( 3, enum3 - enumText_ );
   RFTA_ASSERT_EQUAL( 2, enumEnd - enum3 );
   RFTA_ASSERT_EQUAL( -2, enum3 - enumEnd );
   RFTA_ASSERT_EQUAL( -3, enumText_ - enum3 );
}

void 
CStringEnumeratorTest::testEquality()
{
   Xtl::CStringEnumerator enumEnd = enumText_ + 5;
   Xtl::CStringEnumerator enum2 = enumText_ + 2;
   CPPUNIT_ASSERT( enumText_ == enumText_ );
   CPPUNIT_ASSERT( enum2 == enum2 );
   CPPUNIT_ASSERT( enumEnd == enumEnd );
   CPPUNIT_ASSERT( enumText_ +5 == enumEnd );
   CPPUNIT_ASSERT( enumText_ != enumEnd );
   CPPUNIT_ASSERT( enumText_ != enum2 );
}

void 
CStringEnumeratorTest::testComparable()
{
   Xtl::CStringEnumerator enumEnd = enumText_ + 5;
   Xtl::CStringEnumerator enum2 = enumText_ + 2;
   CPPUNIT_ASSERT( enumText_ < enumEnd );
   CPPUNIT_ASSERT( enumText_ < enum2 );
   CPPUNIT_ASSERT( !(enumText_ < enumText_ ) );

   CPPUNIT_ASSERT( enumText_ <= enumEnd );
   CPPUNIT_ASSERT( enumText_ <= enumText_ );

   CPPUNIT_ASSERT( !(enumText_ >= enumEnd) );
   CPPUNIT_ASSERT( enumEnd >= enumText_);
   CPPUNIT_ASSERT( enumEnd >= enum2);

   CPPUNIT_ASSERT( !(enumText_ > enumEnd) );
   CPPUNIT_ASSERT( enumEnd > enumText_);
   CPPUNIT_ASSERT( enumEnd > enum2);
}

} // namespace Refactoring

--- NEW FILE: CStringEnumeratorTest.h ---
// //////////////////////////////////////////////////////////////////////////
// (c)Copyright 2002, Baptiste Lepilleur.
// Created: 2003/04/26
// //////////////////////////////////////////////////////////////////////////
#ifndef RFTA_CSTRINGENUMERATORTEST_H
#define RFTA_CSTRINGENUMERATORTEST_H

#include "UnitTesting.h"
#include <xtl/CStringView.h>

namespace Refactoring
{

/// Unit tests for CStringEnumeratorTest
class CStringEnumeratorTest : public CppUnit::TestFixture
{
   CPPUNIT_TEST_SUITE( CStringEnumeratorTest );
   CPPUNIT_TEST( testDefaultConstructor );
   CPPUNIT_TEST( testStringConstructor );
   CPPUNIT_TEST( testIncrement );
   CPPUNIT_TEST( testIndex );
   CPPUNIT_TEST( testDecrement );
   CPPUNIT_TEST( testAddable );
   CPPUNIT_TEST( testSubstractable );
   CPPUNIT_TEST( testDistance );
   CPPUNIT_TEST( testEquality );
   CPPUNIT_TEST( testComparable );
   CPPUNIT_TEST_SUITE_END();

public:
   /*! Constructs a CStringEnumeratorTest object.
    */
   CStringEnumeratorTest();

   /// Destructor.
   virtual ~CStringEnumeratorTest();

   void setUp();
   void tearDown();

   void testDefaultConstructor();
   void testStringConstructor();

   void testIncrement();
   void testIndex();
   void testDecrement();

   void testAddable();
   void testSubstractable();

   void testDistance();
   void testEquality();
   void testComparable();

private:
   const std::string text_;
   Xtl::CStringEnumerator enumText_;
   Xtl::CStringView string_;
};

// Inlines methods for CStringEnumeratorTest:
// ------------------------------------------

} // namespace Refactoring

#endif  // RFTA_CSTRINGENUMERATORTEST_H

--- NEW FILE: CStringViewTest.cpp ---
// //////////////////////////////////////////////////////////////////////////
// (c)Copyright 2002, Baptiste Lepilleur.
// Created: 2003/04/26
// //////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "CStringViewTest.h"

namespace Refactoring
{

RFTAPARSER_TEST_SUITE_REGISTRATION( CStringViewTest );

CStringViewTest::CStringViewTest()
   : text_( "123456789" )
   , start_( text_.c_str() )
   , end_( start_ + text_.length() )
{
}

CStringViewTest::~CStringViewTest()
{
}

void 
CStringViewTest::setUp()
{
   RFTA_ASSERT_EQUAL( 9, text_.length() );
}

void 
CStringViewTest::tearDown()
{
}

void 
CStringViewTest::testDefaultConstructor()
{
   Xtl::CStringView empty;
   RFTA_ASSERT_EQUAL( 0, empty.getLength() );
   CPPUNIT_ASSERT( empty.getStart() == 0 );
   CPPUNIT_ASSERT( empty.getEnd() == 0 );
   CPPUNIT_ASSERT( empty.isEmpty() );

   Xtl::CStringView emptySlice( empty.getSlice(0,0) );
   CPPUNIT_ASSERT( emptySlice.isEmpty() );
   RFTA_ASSERT_EQUAL( 0, emptySlice.getLength() );
}

void 
CStringViewTest::testRangeConstructor()
{
   Xtl::CStringView s1( start_, end_ );
   RFTA_ASSERT_EQUAL( start_, s1.getStart() );
   RFTA_ASSERT_EQUAL( end_, s1.getEnd() );
   RFTA_ASSERT_EQUAL( text_.length(), s1.getLength() );
   CPPUNIT_ASSERT( !s1.isEmpty() );

   Xtl::CStringView s2( start_, 0 );
   CPPUNIT_ASSERT( s2.isEmpty() );
   CPPUNIT_ASSERT( s2.getStart() == 0 );
   CPPUNIT_ASSERT( s2.getEnd() == 0 );

   Xtl::CStringView s3( 0, end_ );
   CPPUNIT_ASSERT( s3.isEmpty() );
   CPPUNIT_ASSERT( s3.getStart() == 0 );
   CPPUNIT_ASSERT( s3.getEnd() == 0 );
}

void 
CStringViewTest::testGetSlice()
{
   Xtl::CStringView s1( start_, end_ );
   Xtl::CStringView s2( s1.getSlice( 0, s1.getLength() ) );
   RFTA_ASSERT_EQUAL( s1.getStart(), s2.getStart() );
   RFTA_ASSERT_EQUAL( s1.getEnd(), s2.getEnd() );
   RFTA_ASSERT_EQUAL( s1.getLength(), s2.getLength() );

   Xtl::CStringView s3( s1.getSlice( 0, 3 ) );
   RFTA_ASSERT_EQUAL( s1.getStart(), s3.getStart() );
   RFTA_ASSERT_EQUAL( s1.getStart() + 3, s3.getEnd() );
   RFTA_ASSERT_EQUAL( 3, s3.getLength() );

   Xtl::CStringView s4( s1.getSlice( 5, s1.getLength() ) );
   RFTA_ASSERT_EQUAL( s1.getStart()+5, s4.getStart() );
   RFTA_ASSERT_EQUAL( s1.getEnd(), s4.getEnd() );
   RFTA_ASSERT_EQUAL( s1.getLength()-5, s4.getLength() );

   Xtl::CStringView s5( s1.getSlice( 4, 7 ) );
   RFTA_ASSERT_EQUAL( s1.getStart()+4, s5.getStart() );
   RFTA_ASSERT_EQUAL( s1.getStart()+7, s5.getEnd() );
   RFTA_ASSERT_EQUAL( 7-4, s5.getLength() );

   Xtl::CStringView s6( s1.getSlice( 5 ) );
   RFTA_ASSERT_EQUAL( s1.getStart()+5, s6.getStart() );
   RFTA_ASSERT_EQUAL( s1.getEnd(), s6.getEnd() );
   RFTA_ASSERT_EQUAL( s1.getLength()-5, s6.getLength() );

   RFTA_ASSERT_THROW( s1.getSlice( -1 ), std::out_of_range );
   RFTA_ASSERT_THROW( s1.getSlice( 13 ), std::out_of_range );
   RFTA_ASSERT_THROW( s1.getSlice( 10 ), std::out_of_range );
   RFTA_ASSERT_THROW( s1.getSlice( 1, 13 ), std::out_of_range );
   RFTA_ASSERT_THROW( s1.getSlice( 1, 10 ), std::out_of_range );
}

void 
CStringViewTest::testEnumerate()
{
   Xtl::CStringView empty;
   Xtl::CStringEnumerator enumEmpty( empty.enumerate() );
   CPPUNIT_ASSERT( enumEmpty.getCurrentPos() == 0 );
   CPPUNIT_ASSERT( enumEmpty.getString().getStart() == 0 );
   CPPUNIT_ASSERT( enumEmpty.getString().getEnd() == 0 );

   Xtl::CStringView s1( start_, end_ );
   Xtl::CStringEnumerator enumS1( s1.enumerate() );
   CPPUNIT_ASSERT( enumS1.getCurrentPos() == start_ );
   CPPUNIT_ASSERT( enumS1.getString().getStart() == start_ );
   CPPUNIT_ASSERT( enumS1.getString().getEnd() == end_ );
}

void 
CStringViewTest::testEqual()
{
   Xtl::CStringView s1( start_, end_ );
   Xtl::CStringView s2( start_, end_ );
   CPPUNIT_ASSERT( s1 == s2 );

   const std::string text2( "123456789abcdef" );
   Xtl::CStringView s3( text2.c_str(), text2.c_str() + text2.length() );
   CPPUNIT_ASSERT( s1 != s3 );

   Xtl::CStringView s4( s3.getSlice(0, 9) );
   CPPUNIT_ASSERT( s1 == s4 );

   Xtl::CStringView s5( s3.getSlice(2, 11) );
   CPPUNIT_ASSERT( s1 != s5 );
}

void 
CStringViewTest::testEqualToString()
{
   Xtl::CStringView s1( start_, end_ );
   CPPUNIT_ASSERT( s1 == text_ );
   CPPUNIT_ASSERT( text_ == s1 );
}

} // namespace Refactoring

--- NEW FILE: CStringViewTest.h ---
// //////////////////////////////////////////////////////////////////////////
// (c)Copyright 2002, Baptiste Lepilleur.
// Created: 2003/04/26
// //////////////////////////////////////////////////////////////////////////
#ifndef RFTA_CSTRINGVIEWTEST_H
#define RFTA_CSTRINGVIEWTEST_H

#include "UnitTesting.h"
#include <xtl/CStringView.h>

namespace Refactoring
{

/// Unit tests for CStringViewTest
class CStringViewTest : public CppUnit::TestFixture
{
   CPPUNIT_TEST_SUITE( CStringViewTest );
   CPPUNIT_TEST( testDefaultConstructor );
   CPPUNIT_TEST( testRangeConstructor );
   CPPUNIT_TEST( testGetSlice );
   CPPUNIT_TEST( testEnumerate );
   CPPUNIT_TEST( testEqual );
   CPPUNIT_TEST( testEqualToString );
   CPPUNIT_TEST_SUITE_END();

public:
   /*! Constructs a CStringViewTest object.
    */
   CStringViewTest();

   /// Destructor.
   virtual ~CStringViewTest();

   void setUp();
   void tearDown();

   void testDefaultConstructor();
   void testRangeConstructor();
   void testGetSlice();
   void testEnumerate();
   void testEqual();
   void testEqualToString();

private:
   const std::string text_;
   const char *const start_;
   const char *const end_;
};

// Inlines methods for CStringViewTest:
// ------------------------------------

} // namespace Refactoring

#endif  // RFTA_CSTRINGVIEWTEST_H

[Cpptool-cvs] rfta/src/rftaparser CStringEnumeratorTest.cpp,NONE,1.1 CStringEnumeratorTest.h,NONE,1.

[Cpptool-cvs] rfta/src/rftaparser CStringEnumeratorTest.cpp,NONE,1.1 CStringEnumeratorTest.h,NONE,1.1 CStringViewTest.cpp,NONE,1.1 CStringViewTest.h,NONE,1.1