---

test-verifier.cc

/*
*  Name:      test-verifier.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Test for base invariant verifier
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-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 <mpcl/invariant/verifier.hh>
#include <mpcl/test.h>


using mpcl::invariant::IVerifier;


class TVerifier : public IVerifier<int>
{

  public:

    enum { FIRST_LEVEL, SECOND_LEVEL, THIRD_LEVEL };
    enum { FIRST_RULE, SECOND_RULE, THIRD_RULE, FOURTH_RULE };
      

  public:

    //
    //  C O N S T R U C T O R S
    //

    TVerifier (void)               :
      IVerifier<int> (FIRST_LEVEL) {}
    

  public:

    //
    //  S E L E C T O R S
    //
    
    bool verify (long int liINVARIANT_IDENTIFIER) const;

};  // class TVerifier


bool TVerifier::verify (long int liINVARIANT_IDENTIFIER) const
{

  bool   gSuccess = false;

  switch (liINVARIANT_IDENTIFIER)
  {
    case FIRST_RULE:
    {
      gSuccess = ( tArgumentArray [0] < 1000 );
      break;
    }
    case SECOND_RULE:
    {
      gSuccess = ( tArgumentArray [0] < 100 );
      break;
    }
    case THIRD_RULE:
    {
      gSuccess = ( tArgumentArray [0] < 10 );
      break;
    }
    case FOURTH_RULE:
    {
      gSuccess = ( tArgumentArray [0] < 1 );
      break;
    }
  }
  return gSuccess;

}  // TVerifier::verify()
 

int main (void)
{

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

  TVerifier   tRV;
  
  tRV.tConformanceLevelSet.insert (TVerifier::FIRST_LEVEL);
  tRV.tConformanceLevelSet.insert (TVerifier::SECOND_LEVEL);
  tRV.tConformanceLevelSet.insert (TVerifier::THIRD_LEVEL);

  tRV.addInvariant (TVerifier::FIRST_RULE,  TVerifier::FIRST_LEVEL,  "Less than 1000");
  tRV.addInvariant (TVerifier::SECOND_RULE, TVerifier::FIRST_LEVEL,  "Less than 100");
  tRV.addInvariant (TVerifier::THIRD_RULE,  TVerifier::SECOND_LEVEL, "Less than 10");
  tRV.addInvariant (TVerifier::FOURTH_RULE, TVerifier::THIRD_LEVEL,  "Less than 1");

  tRV.require (TVerifier::FIRST_RULE, 999);

  tRV.tConformanceLevelSet.erase (TVerifier::FIRST_LEVEL);
  tRV.require (TVerifier::FIRST_RULE,  1000);
  tRV.require (TVerifier::SECOND_RULE, 1000);
  tRV.require (TVerifier::THIRD_RULE,     9);

  TEST_MEMORY_STATUS;
  TEST_RETURN_CODE;

}  // main()

---