LCOV - code coverage report
Current view: top level - bes/test - traverser_test.cpp (source / functions) Hit Total Coverage
Test: mcrl2_coverage.info.cleaned Lines: 46 46 100.0 %
Date: 2019-06-20 00:49:45 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Author(s): Wieger Wesselink
       2             : // Copyright: see the accompanying file COPYING or copy at
       3             : // https://github.com/mCRL2org/mCRL2/blob/master/COPYING
       4             : //
       5             : // Distributed under the Boost Software License, Version 1.0.
       6             : // (See accompanying file LICENSE_1_0.txt or copy at
       7             : // http://www.boost.org/LICENSE_1_0.txt)
       8             : //
       9             : /// \file traverser_test.cpp
      10             : /// \brief Test for traversers.
      11             : 
      12             : #include "mcrl2/bes/parse.h"
      13             : #include "mcrl2/bes/traverser.h"
      14             : #include <algorithm>
      15             : #include <boost/test/minimal.hpp>
      16             : #include <iterator>
      17             : #include <set>
      18             : #include <vector>
      19             : 
      20             : using namespace mcrl2;
      21             : using namespace mcrl2::bes;
      22             : 
      23             : class custom_traverser: public boolean_expression_traverser<custom_traverser>
      24             : {
      25             :   public:
      26             :     typedef boolean_expression_traverser<custom_traverser> super;
      27             : 
      28             :     using super::enter;
      29             :     using super::leave;
      30             :     using super::apply;
      31             : };
      32             : 
      33           1 : void test_custom_traverser()
      34             : {
      35             :   custom_traverser t;
      36             : 
      37           2 :   boolean_variable v;
      38           1 :   t.apply(v);
      39             : 
      40           2 :   true_ T;
      41           1 :   t.apply(T);
      42             : 
      43           2 :   boolean_expression e;
      44           1 :   t.apply(e);
      45             : 
      46           2 :   boolean_equation eq;
      47           1 :   t.apply(eq);
      48             : 
      49           2 :   boolean_equation_system eqn;
      50           1 :   t.apply(eqn);
      51             : 
      52           1 : }
      53             : 
      54             : class traverser1: public boolean_variable_traverser<traverser1>
      55             : {
      56             :   public:
      57             :     typedef boolean_variable_traverser<traverser1> super;
      58             : 
      59             :     using super::enter;
      60             :     using super::leave;
      61             :     using super::apply;
      62             : 
      63             :     unsigned int variable_count;
      64             :     unsigned int equation_count;
      65             :     unsigned int expression_count;
      66             : 
      67           2 :     traverser1()
      68             :       : variable_count(0),
      69             :         equation_count(0),
      70           2 :         expression_count(0)
      71           2 :     {}
      72             : 
      73           8 :     void enter(const boolean_variable& v)
      74             :     {
      75           8 :       variable_count++;
      76           8 :     }
      77             : 
      78           2 :     void enter(const boolean_equation& eq)
      79             :     {
      80           2 :       equation_count++;
      81           2 :     }
      82             : 
      83           8 :     void enter(const boolean_expression& x)
      84             :     {
      85           8 :       expression_count++;
      86           8 :     }
      87             : };
      88             : 
      89           1 : void test_traverser1()
      90             : {
      91           1 :   traverser1 t1;
      92           2 :   boolean_expression x = boolean_variable("X");
      93           1 :   t1.apply(x);
      94             : 
      95           1 :   BOOST_CHECK(t1.variable_count == 1);
      96           1 :   BOOST_CHECK(t1.expression_count == 1);
      97           1 :   BOOST_CHECK(t1.equation_count == 0);
      98             : 
      99             :   //--------------------------//
     100             : 
     101           1 :   traverser1 t2;
     102             : 
     103             :   std::string bes1 =
     104             :     "pbes              \n"
     105             :     "                  \n"
     106             :     "nu X1 = X2 && X1; \n"
     107             :     "mu X2 = X1 || X2; \n"
     108             :     "                  \n"
     109           2 :     "init X1;          \n"
     110             :     ;
     111           2 :   boolean_equation_system b;
     112           2 :   std::stringstream from(bes1);
     113           1 :   from >> b;
     114             : 
     115           1 :   t2.apply(b);
     116             : 
     117           1 :   BOOST_CHECK(t2.variable_count == 7);
     118           1 :   BOOST_CHECK(t2.expression_count == 7);
     119           1 :   BOOST_CHECK(t2.equation_count == 2);
     120             : 
     121           1 : }
     122             : 
     123           1 : int test_main(int argc, char* argv[])
     124             : {
     125           1 :   test_custom_traverser();
     126           1 :   test_traverser1();
     127             : 
     128           1 :   return EXIT_SUCCESS;
     129           3 : }

Generated by: LCOV version 1.12