---

test-streamable_dfa.cc

/*
*  Name:      test-streamable_dfa.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Test for Streamable Deterministic Finite Automaton
*  Date:      $Date: 2003/10/06 12:45:11 $
*  Revision:  $Revision: 1.2 $
*
*  Copyright (C) 1999-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#include <fstream>
#include <mpcl/automaton/streamable_dfa.hh>
#include <mpcl/io/output_streamable.hh>
#include <mpcl/test.h>
#include <sstream>


using mpcl::automaton::TStreamableDfa;
using mpcl::event::TEventHandler;
using mpcl::io::IOutputStreamable;
using std::basic_ostringstream;
using std::basic_ifstream;
using std::basic_ostream;


//
//  L O C A L   T Y P E S
//

class TTestEvent : public IOutputStreamable<>
{

  private:

    char   cValue;


  protected:

    void write (basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const
    {
      rtTARGET_OSTREAM << cValue;
    }


  public:

    TTestEvent (void)            :
      IOutputStreamable<> ()     ,
      cValue              ('\0') {}

    TTestEvent (char cSOURCE)       :
      IOutputStreamable<> ()        ,
      cValue              (cSOURCE) {}

    bool operator < (const TTestEvent&) const
    {
      return false;
    }

    bool operator == (const TTestEvent& rktSOURCE_EVENT) const
    {
      return ( cValue == rktSOURCE_EVENT.cValue );
    }

};  // class TTestEvent


class TTestStreamableDfa : public TStreamableDfa<int, TTestEvent>
{

  public:
    
    TTestStreamableDfa (TEventHandler<TTestEvent>& rtSOURCE_EVENT_HANDLER) :
      TStreamableDfa<int, TTestEvent> (rtSOURCE_EVENT_HANDLER)
    {
      tStringToEventMap.bind ("event_zero",  TTestEvent ('0'));
      tStringToEventMap.bind ("event_one",   TTestEvent ('1'));
      tStringToEventMap.bind ("event_two",   TTestEvent ('2'));
      tStringToEventMap.bind ("event_three", TTestEvent ('3'));
    }

};  // class TTestStreamableDfa


int main (void)
{

  TEST_INIT ("tests for class 'TStreamableDfa'");

  try
  {
    TEventHandler<TTestEvent>   tEventHandler;
    basic_ostringstream<char>   tOutputOstringstream;
    basic_ifstream<char>        tInputIfstream ("test-streamable_dfa.dfaml");
    TTestStreamableDfa          tTestSDFA (tEventHandler);

    //
    //  This is the path to the final state.
    //
    tEventHandler.push (TTestEvent ('0'));
    tEventHandler.push (TTestEvent ('1'));
    tEventHandler.push (TTestEvent ('2'));
    tEventHandler.push (TTestEvent ('3'));
    tInputIfstream >> tTestSDFA;
    if ( TEST_IN_SILENT_MODE )
    {
      tOutputOstringstream << tTestSDFA;
    }
    else
    {
      std::cerr << tTestSDFA;
    }
    tTestSDFA.start();
    TEST_PASS;
  }
  catch (const mpcl::TException& rktEXCEPTION)
  {
    if ( !TEST_IN_SILENT_MODE )
    {
      fprintf ( hptTestTargetFile                          ,
                "#ERROR: %s:%d:%s; %s\n"                   ,
                rktEXCEPTION.fileName().c_str()            ,
                rktEXCEPTION.lineNumber()                  ,
                rktEXCEPTION.generalDescription().c_str()  ,
                rktEXCEPTION.specificDescription().c_str() );
    }
    TEST_FAIL;
  }
  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // main()

---