From: <bl...@us...> - 2003-04-26 12:09:48
|
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 |