Ideas for UT needed

13 Feb 2013

      Hello,

for my project I use the ideas used on spirit's conjure2 example. Now I 
like to do some test with the lexer/grammar using boost::test. The 
example uses sequentially initializing all iterators, lexer and grammar. 
I like to put this into the fixture but I run into the problem that the 
error_handler requires begin/end of iterator.

---8<--- original from conjure2 main
     typedef std::string::const_iterator base_iterator_type;
     typedef client::lexer::conjure_tokens
                                                   lexer_type;
     typedef lexer_type::iterator_type iterator_type;

     lexer_type lexer;                           // Our lexer

     base_iterator_type first = source_code.begin();
     base_iterator_type last = source_code.end();

     iterator_type iter = lexer.begin(first, last);
     iterator_type end = lexer.end();

     client::error_handler
         error_handler(first, last);             // Our error handler
     client::parser::function
         function(error_handler, lexer);         // Our parser
--->8---

My fixture looks so far:

---8<---
     typedef std::string::const_iterator base_iterator_type;
     typedef my_tokens lexer_type;
     typedef lexer_type::iterator_type iterator_type;
     typedef error_handler
                                             error_handler_type;

     struct fixture
	    : private boost::base_from_member,
	      private boost::base_from_member,
	      my_grammar
     {
	typedef boost::base_from_member lexer_base;
         typedef boost::base_from_member
                                                 error_handler_base;
	typedef my_grammar grammar_base;

	fixture() : grammar_base(error_handler_base::member,
                                 lexer_base::member) {

	}

     };
--->8---

error_handler_base::member requires therefore the iterators first/last. 
How to give them? In the UT I have further a "test" function object so I 
can use e.g. it like here:

---8<---
BOOST_FIXTURE_TEST_SUITE(parameter_test, fixture)

BOOST_AUTO_TEST_CASE(my_test) {

     BOOST_CHECK(test(rule_to_test,
                     "input to parse",
                     "expected output"));
}

--->8---

The next problem is related to the original use case. conjure2 is design 
as a compiler: initialize, analyse, generate and exit - no reuse of the 
grammar. I like to instance the grammar once (static) and use it several 
times using the qi::parse function. Since the iterators are fixed, they 
can't be changed later to point to other sources, isn't it? Is this the 
right approach for my problem?

Thanks,
Olaf

Olaf Peter

legalize+jeeves＠mail.xmission.com

Olaf Peter

legalize+jeeves＠mail.xmission.com

tags

participants (2)