LCOV - code coverage report
Current view: top level - bes/test - traverser_test.cpp (source / functions) Hit Total Coverage
Test: mcrl2_coverage.info.cleaned Lines: 45 45 100.0 %
Date: 2019-09-14 00:54:39 Functions: 10 10 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             : #define BOOST_TEST_MODULE traverser_test
      13             : #include "mcrl2/bes/parse.h"
      14             : #include "mcrl2/bes/traverser.h"
      15             : #include <algorithm>
      16             : #include <boost/test/included/unit_test_framework.hpp>
      17             : #include <iterator>
      18             : #include <set>
      19             : #include <vector>
      20             : 
      21             : using namespace mcrl2;
      22             : using namespace mcrl2::bes;
      23             : 
      24             : class custom_traverser: public boolean_expression_traverser<custom_traverser>
      25             : {
      26             :   public:
      27             :     typedef boolean_expression_traverser<custom_traverser> super;
      28             : 
      29             :     using super::enter;
      30             :     using super::leave;
      31             :     using super::apply;
      32             : };
      33             : 
      34           1 : void test_custom_traverser()
      35             : {
      36             :   custom_traverser t;
      37             : 
      38           2 :   boolean_variable v;
      39           1 :   t.apply(v);
      40             : 
      41           2 :   true_ T;
      42           1 :   t.apply(T);
      43             : 
      44           2 :   boolean_expression e;
      45           1 :   t.apply(e);
      46             : 
      47           2 :   boolean_equation eq;
      48           1 :   t.apply(eq);
      49             : 
      50           2 :   boolean_equation_system eqn;
      51           1 :   t.apply(eqn);
      52             : 
      53           1 : }
      54             : 
      55             : class traverser1: public boolean_variable_traverser<traverser1>
      56             : {
      57             :   public:
      58             :     typedef boolean_variable_traverser<traverser1> super;
      59             : 
      60             :     using super::enter;
      61             :     using super::leave;
      62             :     using super::apply;
      63             : 
      64             :     unsigned int variable_count;
      65             :     unsigned int equation_count;
      66             :     unsigned int expression_count;
      67             : 
      68           2 :     traverser1()
      69             :       : variable_count(0),
      70             :         equation_count(0),
      71           2 :         expression_count(0)
      72           2 :     {}
      73             : 
      74           8 :     void enter(const boolean_variable& v)
      75             :     {
      76           8 :       variable_count++;
      77           8 :     }
      78             : 
      79           2 :     void enter(const boolean_equation& eq)
      80             :     {
      81           2 :       equation_count++;
      82           2 :     }
      83             : 
      84           8 :     void enter(const boolean_expression& x)
      85             :     {
      86           8 :       expression_count++;
      87           8 :     }
      88             : };
      89             : 
      90           1 : void test_traverser1()
      91             : {
      92           1 :   traverser1 t1;
      93           2 :   boolean_expression x = boolean_variable("X");
      94           1 :   t1.apply(x);
      95             : 
      96           1 :   BOOST_CHECK(t1.variable_count == 1);
      97           1 :   BOOST_CHECK(t1.expression_count == 1);
      98           1 :   BOOST_CHECK(t1.equation_count == 0);
      99             : 
     100             :   //--------------------------//
     101             : 
     102           1 :   traverser1 t2;
     103             : 
     104             :   std::string bes1 =
     105             :     "pbes              \n"
     106             :     "                  \n"
     107             :     "nu X1 = X2 && X1; \n"
     108             :     "mu X2 = X1 || X2; \n"
     109             :     "                  \n"
     110           2 :     "init X1;          \n"
     111             :     ;
     112           2 :   boolean_equation_system b;
     113           2 :   std::stringstream from(bes1);
     114           1 :   from >> b;
     115             : 
     116           1 :   t2.apply(b);
     117             : 
     118           1 :   BOOST_CHECK(t2.variable_count == 7);
     119           1 :   BOOST_CHECK(t2.expression_count == 7);
     120           1 :   BOOST_CHECK(t2.equation_count == 2);
     121             : 
     122           1 : }
     123             : 
     124           3 : BOOST_AUTO_TEST_CASE(test_main)
     125             : {
     126           1 :   test_custom_traverser();
     127           1 :   test_traverser1();
     128           4 : }

Generated by: LCOV version 1.12