cpptool-cvs

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

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

Modified Files:
	rftaparser.dsp 
Added Files:
	MiniParserTest.cpp MiniParserTest.h 
Log Message:
* experimenting with implementation of a simplistic parser framework (akin to Boost.Spirit, but much more simple). Still need to devise how matched parts are returned...

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

#include "stdafx.h"
#include "MiniParserTest.h"


namespace Refactoring
{

RFTAPARSER_TEST_SUITE_REGISTRATION( MiniParserTest );


namespace Testing {
   struct MiniParserAsserter : public Asserter<MiniParserAsserter>
   {
      template<typename Parser>
      Xtl::ParseResult parse( const std::string &text,
                              const Parser &parser )
      {
         Xtl::Scanner scanner( text.c_str(), text.c_str() + text.length() );
         return parser.parse( scanner );
      }

      template<typename Parser>
      void checkParser( const std::string &text,
                        const Parser &parser,
                        int expectedEnd = -1 )
      {
         if ( expectedEnd )
            expectedEnd = text.length();

         Xtl::ParseResult result = parse( text, parser );
         failIf( !result.matched_, "parsing failed" );
         checkEquals( text.c_str(), result.matchStart_, "wrong match start" );
         checkEquals( text.c_str() + expectedEnd, result.matchEnd_ , "wrong match end" );
      }


      template<typename Parser>
      void checkParserFail( const std::string &text,
                            const Parser &parser )
      {
         Xtl::ParseResult result = parse( text, parser );
         failIf( result.matched_, "parsing should have failed" );
      }
   };

#define RFTA_ASSERT_MINIPARSER_PASS \
   RFTA_CUSTOM_ASSERT( Refactoring::Testing::MiniParserAsserter ).checkParser

#define RFTA_ASSERT_MINIPARSER_FAIL \
   RFTA_CUSTOM_ASSERT( Refactoring::Testing::MiniParserAsserter ).checkParserFail

} // namespace Testing


MiniParserTest::MiniParserTest()
{
}


MiniParserTest::~MiniParserTest()
{
}


void 
MiniParserTest::setUp()
{
}


void 
MiniParserTest::tearDown()
{
}


void 
MiniParserTest::testParseChLit()
{
   RFTA_ASSERT_MINIPARSER_PASS( "a", Xtl::CharMiniParser( 'a' ) );
   RFTA_ASSERT_MINIPARSER_FAIL( "b", Xtl::CharMiniParser( 'c' ) );
}


void 
MiniParserTest::testParseString()
{
   RFTA_ASSERT_MINIPARSER_PASS( "abcdef", Xtl::StringMiniParser( "abcdef" ) );
   RFTA_ASSERT_MINIPARSER_PASS( "a", Xtl::StringMiniParser( "a" ) );
   RFTA_ASSERT_MINIPARSER_PASS( "", Xtl::StringMiniParser( "" ) );
   RFTA_ASSERT_MINIPARSER_FAIL( "abcdef", Xtl::StringMiniParser( "abcfgh" ) );
   RFTA_ASSERT_MINIPARSER_FAIL( "", Xtl::StringMiniParser( "a" ) );
}


void 
MiniParserTest::testParseCppIdentifier()
{
   RFTA_ASSERT_MINIPARSER_PASS( "ab_012AC", Xtl::CppIdentifierMiniParser() );
   RFTA_ASSERT_MINIPARSER_PASS( "ABC", Xtl::CppIdentifierMiniParser() );
   RFTA_ASSERT_MINIPARSER_PASS( "a", Xtl::CppIdentifierMiniParser() );
   RFTA_ASSERT_MINIPARSER_PASS( "_", Xtl::CppIdentifierMiniParser() );
   RFTA_ASSERT_MINIPARSER_FAIL( "0", Xtl::CppIdentifierMiniParser() );
}


void 
MiniParserTest::testParseMacroIdentifier()
{
   RFTA_ASSERT_MINIPARSER_PASS( "A0_DEF", Xtl::MacroIdentifierMiniParser() );
   RFTA_ASSERT_MINIPARSER_PASS( "ABC", Xtl::MacroIdentifierMiniParser() );
   RFTA_ASSERT_MINIPARSER_PASS( "_", Xtl::MacroIdentifierMiniParser() );
   RFTA_ASSERT_MINIPARSER_FAIL( "a_c", Xtl::MacroIdentifierMiniParser() );
   RFTA_ASSERT_MINIPARSER_FAIL( "0", Xtl::MacroIdentifierMiniParser() );
}


void 
MiniParserTest::testParseSequence()
{
   RFTA_ASSERT_MINIPARSER_PASS( "->", 
      Xtl::makeSequenceParser( Xtl::CharMiniParser( '-' ), 
                               Xtl::StringMiniParser( ">" ) ) );

   const Xtl::MiniParser &parser = Xtl::CharMiniParser( '-' )  >>  Xtl::CharMiniParser( '>' );
   RFTA_ASSERT_MINIPARSER_PASS( "->", parser );
   RFTA_ASSERT_MINIPARSER_FAIL( "=>", parser );

   const Xtl::MiniParser &parser2 = Xtl::StringMiniParser( "class " )  
                                    >> Xtl::CppIdentifierMiniParser()  
                                    >>  Xtl::CharMiniParser( ':' );
   RFTA_ASSERT_MINIPARSER_PASS( "class SourceRange:", parser2 );
   RFTA_ASSERT_MINIPARSER_FAIL( "class SourceRange{", parser2 );
}


void 
MiniParserTest::testParseOptional()
{
   RFTA_ASSERT_MINIPARSER_PASS( "a", Xtl::makeOptionalParser( Xtl::CharMiniParser( 'a' ) ) );
   RFTA_ASSERT_MINIPARSER_PASS( "ba", Xtl::makeOptionalParser( Xtl::CharMiniParser( 'a' ) ), 0 );
   RFTA_ASSERT_MINIPARSER_PASS( "", Xtl::makeOptionalParser( Xtl::CharMiniParser( 'a' ) ) );

   RFTA_ASSERT_MINIPARSER_PASS( "a", !Xtl::CharMiniParser( 'a' ) );
   RFTA_ASSERT_MINIPARSER_PASS( "b", !Xtl::CharMiniParser( 'a' ), 0 );
   RFTA_ASSERT_MINIPARSER_PASS( "", !Xtl::CharMiniParser( 'a' ) );
}


void 
MiniParserTest::testParseAlternative()
{
   const Xtl::MiniParser &parser = Xtl::makeAlternativeParser( Xtl::CharMiniParser( '-' ), 
                                                               Xtl::CharMiniParser( '>' ) );

   RFTA_ASSERT_MINIPARSER_PASS( "-", parser );
   RFTA_ASSERT_MINIPARSER_PASS( ">", parser );
   RFTA_ASSERT_MINIPARSER_FAIL( "+", parser );
   RFTA_ASSERT_MINIPARSER_FAIL( "", parser );

   const Xtl::MiniParser &parser2 = Xtl::CharMiniParser( '-' ) | Xtl::CharMiniParser( '>' );
   RFTA_ASSERT_MINIPARSER_PASS( "-", parser2 );
   RFTA_ASSERT_MINIPARSER_PASS( ">", parser2 );
   RFTA_ASSERT_MINIPARSER_FAIL( "+", parser2 );
   RFTA_ASSERT_MINIPARSER_FAIL( "", parser2 );
}


} // namespace Refactoring

--- NEW FILE: MiniParserTest.h ---
// //////////////////////////////////////////////////////////////////////////
// (c)Copyright 2002, Baptiste Lepilleur.
// Created: 2003/05/04
// //////////////////////////////////////////////////////////////////////////
#ifndef RFTA_MINIPARSERTEST_H
#define RFTA_MINIPARSERTEST_H

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


namespace Refactoring
{


/// Unit tests for MiniParserTest
class MiniParserTest : public CppUnit::TestFixture
{
   CPPUNIT_TEST_SUITE( MiniParserTest );
   CPPUNIT_TEST( testParseChLit );
   CPPUNIT_TEST( testParseString );
   CPPUNIT_TEST( testParseCppIdentifier );
   CPPUNIT_TEST( testParseMacroIdentifier );
   CPPUNIT_TEST( testParseSequence );
   CPPUNIT_TEST( testParseOptional );
   CPPUNIT_TEST( testParseAlternative );
   CPPUNIT_TEST_SUITE_END();

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

   /// Destructor.
   virtual ~MiniParserTest();

   void setUp();
   void tearDown();

   void testParseChLit();
   void testParseString();

   void testParseCppIdentifier();
   void testParseMacroIdentifier();

   void testParseSequence();

   void testParseOptional();

   void testParseAlternative();

private:
};



// Inlines methods for MiniParserTest:
// -----------------------------------


} // namespace Refactoring



#endif  // RFTA_MINIPARSERTEST_H


Index: rftaparser.dsp
===================================================================
RCS file: /cvsroot/cpptool/rfta/src/rftaparser/rftaparser.dsp,v
retrieving revision 1.51
retrieving revision 1.52
diff -C2 -d -r1.51 -r1.52
*** rftaparser.dsp	4 May 2003 06:56:09 -0000	1.51
--- rftaparser.dsp	4 May 2003 18:19:28 -0000	1.52
***************
*** 158,161 ****
--- 158,165 ----
  # Begin Source File
  
+ SOURCE=..\..\include\xtl\MiniParser.h
+ # End Source File
+ # Begin Source File
+ 
  SOURCE=..\..\include\xtl\NullEnumerator.h
  # End Source File
***************
*** 672,675 ****
--- 676,687 ----
  !ENDIF 
  
+ # End Source File
+ # Begin Source File
+ 
+ SOURCE=.\MiniParserTest.cpp
+ # End Source File
+ # Begin Source File
+ 
+ SOURCE=.\MiniParserTest.h
  # End Source File
  # End Group