ippCommandParserTestCase.cpp

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 
//
#define _CRT_SECURE_NO_DEPRECATE

#include "ippCommandParserTestCase.h"
#include "ippMemoryLeakDetector.h"

#include "ippdme/Parser/ippCommandParser.h"
#include "ippdme/Command/ippCommand.h"
#include "ippdme/ippCommandNameType.h"

#include "ippdme/ippError.h"
#include "ippUtest.h"
#include "ippTestFolder.h"

#ifdef GetProp 
#undef GetProp
#endif

namespace CxxTest {


   CXXTEST_TEMPLATE_INSTANTIATION
   class ValueTraits<ippParserCmdErrorId>  
   {
    ippParserCmdErrorId _t;
    std::ostringstream _s;
  public:
    ValueTraits(ippParserCmdErrorId t ) 
      :_t(t)
    {
      _s << getIppErr(_t).asInteger() << std::endl;
    }
    ValueTraits( const ValueTraits<ippParserCmdErrorId>& t ) ;
   const char *asString( void ) const { 
      return toString(_t) ; 
   }
  };
//xx   CXXTEST_ENUM_TRAITS
//xx     CXXTEST_COPY_CONST_TRAITS( parserCmdErrorId );

   CXXTEST_TEMPLATE_INSTANTIATION
   class ValueTraits<ippCommandNameType>
   {
     ippCommandNameType _t;
   public:
     ValueTraits( ippCommandNameType t ) 
       :_t(t)
     { }
     ValueTraits( const ValueTraits<ippCommandNameType>& t ) ;
       const char *asString( void ) const { return getCommandNameString(_t); }
   };    
//xx  CXXTEST_COPY_CONST_TRAITS( ippCommandNameType );
}




#define IPP_END_STRING "\r\n"

void ippCommandParserTestCase::setUp()
{
  // _CrtSetBreakAlloc(141);
  //xx std::cout << "_MSC_VER=" << _MSC_VER << std::endl;

}
void ippCommandParserTestCase::tearDown()
{
}


void ippCommandParserTestCase::test1 ()
{
  ippMemoryLeakDetector _leakDetector;
  
  ippCommandParser cmdParser;
  
  ippCommandConstPtr pCommand;

  cmdParser.setInput("00001 StartSession()"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT_EQUALS(pCommand->getCommandName(), StartSession);

  cmdParser.setInput("00099 EndSession()"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 99);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT_EQUALS(pCommand->getCommandName(), EndSession);

}


void ippCommandParserTestCase::testInvalidCommands()
{
  ippMemoryLeakDetector _leakDetector;

  ippCommandParser cmdParser;

  ippCommandPtr pCommand=NULL;
         
  // test a StartSession with a extra arguement : 
  cmdParser.setInput("00001 StartSession(23.0)"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),MUST_HAVE_NO_ARGUMENTS);

  // test a EndSession with a extra arguement : 
  cmdParser.setInput("00001 EndSession(\"a\")"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),MUST_HAVE_NO_ARGUMENTS);

  // invalid X and Y : missing parenthesis
  cmdParser.setInput("00001 OnPtMeasReport(X,Y)"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),BAD_ARGUMENTS);

  // invalid : X() is duplicated
  cmdParser.setInput("00001 OnPtMeasReport(X(),X())"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),X_ARGUMENT_USED_TWICE);

  // invalid no argument specified
  cmdParser.setInput("00001 OnPtMeasReport()"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),BAD_ARGUMENTS);

  cmdParser.setInput("00001 OnPtMeasReport(X(),Y,)"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),BAD_ARGUMENTS);

}

void ippCommandParserTestCase::testOnMoveReportE()
{
  ippMemoryLeakDetector _leakDetector;

  ippCommandParser cmdParser;

  ippCommandPtr pCommand=NULL;
 // test with Y alone
  cmdParser.setInput("E0025 OnMoveReportE(Y(),Time(0.5))"IPP_END_STRING);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),OK);

}
void ippCommandParserTestCase::testOnPtMeas()
{
  ippMemoryLeakDetector _leakDetector;

  ippCommandParser cmdParser;

  ippCommandPtr pCommand=NULL;
  
  // test with X and Y 
  cmdParser.setInput("00025 PtMeas(X(1.0),Y(2.))"IPP_END_STRING);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),OK);

  // test with X and Y and IJK 
  cmdParser.setInput("00025 PtMeas(X(1.0),Y(2.),IJK(0.,1.,2.))"IPP_END_STRING);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),OK);

  // test with X and Y and IJK  in a different order
  cmdParser.setInput("00025 PtMeas(X(1.0),IJK(0.,1.,2.),Y(2.))"IPP_END_STRING);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),OK);
}

void ippCommandParserTestCase::testOnPtMeasReport()
{
  ippMemoryLeakDetector _leakDetector;

  ippCommandParser cmdParser;

  ippCommandPtr pCommand=NULL;
 // test with Y alone
  cmdParser.setInput("00001 OnPtMeasReport(Y())"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),OK);

  // test with Y first then X
  cmdParser.setInput("00001 OnPtMeasReport(Y(),X())"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),OK);

  // test with Y first then Tool.B
  cmdParser.setInput("00001 OnPtMeasReport(Y(),Tool.B())"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),OK);

  // test with Y first then Tool.B
  cmdParser.setInput("00001 OnPtMeasReport(Tool.B(),Y())"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 1);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getParserErr(),OK);
}

void ippCommandParserTestCase::testGetProp()
{
  ippCommandParser cmdParser;

  {
    // test a StartSession with a extra arguement : 
    cmdParser.setInput("00060 GetProp(Tool.PtMeasPar.Approach(), Tool.PtMeasPar.Retract(), Tool.PtMeasPar.Search())"IPP_END_STRING);
    cmdParser.parseTag();
    IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 60);  
    ippCommandPtr command= cmdParser.parseCommand();
    IPP_UTEST_ASSERT_EQUALS(command->getCommandName(), ipp::GetProp);
  }
  {
    cmdParser.setInput("00025 GetProp(Tool.X.Accel())\r\n");
    ippCommandPtr command= cmdParser.parseCommand();
    IPP_UTEST_ASSERT(!command);
  }
   

}
#include "ippdme/Command/ippGoToCommand.h"

void ippCommandParserTestCase::testCommandWithArguments()
{
  ippMemoryLeakDetector _leakDetector;

  ippCommandParser cmdParser;

  ippCommandPtr pCommand=NULL;

  cmdParser.setInput("00070 GoTo(X(20), Y(40), Z(60))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT_EQUALS(pCommand->getCommandName(), ipp::GoTo);
  ippGoToCommandPtr pGotoCommand = static_cast<ippGoToCommand*>(pCommand.get());
  IPP_UTEST_ASSERT_EQUALS(pGotoCommand->getX() ,20.0)
  IPP_UTEST_ASSERT_EQUALS(pGotoCommand->getY() ,40.0)
  IPP_UTEST_ASSERT_EQUALS(pGotoCommand->getZ() ,60.0)

  cmdParser.setInput("00040 SetProp(Tool.GoToPar.Accel(50.0))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 40);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT_EQUALS(pCommand->getCommandName(), ipp::SetProp );

}

void ippCommandParserTestCase::testScanOnCurve_BadFormat()
{
  ippMemoryLeakDetector _leakDetector;
  ippCommandParser cmdParser;
  {
    // a small test that verifies the ability of the parser
    // to cope with wrongly defined "Format" in teh ScanOnCurve
    ippCommandPtr pCommand;

    cmdParser.setInput("00070 ScanOnCurve(Closed(0),"
                       "Format(X(),Y(),Z(),wrong,stuff),"
                       "Data(10.0))"IPP_END_STRING);
    cmdParser.parseTag();
    IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
    pCommand = cmdParser.parseCommand();
    IPP_UTEST_ASSERT(!pCommand);
    IPP_UTEST_ASSERT_EQUALS(BAD_SYNTAX_FOR_FORMAT_IN_SCANONCURVE,cmdParser.getParserErr());
  }
}

void ippCommandParserTestCase::testScanOnCurve_Format1_OK()
{
  ippMemoryLeakDetector _leakDetector;
  ippCommandParser cmdParser;
  // form 1
  ippCommandPtr pCommand;
  cmdParser.setInput("00070 ScanOnCurve(Closed(0),"
                     "Format(X(),Y(),Z(),IJK(),tag),"
                     "Data(1.,2.,3.,0.,0.,1.,555,1.,2.,3.,0.,0.,1.,666))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  if (!pCommand) return;
  IPP_UTEST_ASSERT_EQUALS(pCommand->getCommandName(), ipp::ScanOnCurve);
}

void ippCommandParserTestCase::testScanOnCurve_Format1_BadData()
{
  ippMemoryLeakDetector _leakDetector;
  ippCommandParser cmdParser;
  // form 1  - not well formed ( with wrong number of data )
  ippCommandPtr pCommand;
  cmdParser.setInput("00070 ScanOnCurve(Closed(0),"
                     "Format(X(),Y(),Z(),IJK(),tag,pi,pj,pk),"
                     "Data(1., 2., 2. , 0,0,1, 555,0,0,1,"
                          "1., 2., 2. , 0,0,1, 555,0,0,1,0,0,0"
                     "))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(BAD_NUMBER_OF_ARGUMENT_FOR_DATA_IN_SCANONCURVE,cmdParser.getParserErr());
}

void ippCommandParserTestCase::testScanOnCurve_Format2_OK()
{
  ippMemoryLeakDetector _leakDetector;
  ippCommandParser cmdParser;
  // form 2
  ippCommandPtr pCommand;
  cmdParser.setInput("00070 ScanOnCurve(Closed(0),"
                     "Format(X(),Y(),Z(),IJK(),tag,pi,pj,pk),"
                     "Data(1.,2.,3.,0.,0.,1.,3.,4.,5.,555,1.,2.,3.,0.,0.,1.,3.,4.,5.,666))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  if (!pCommand) return;
  IPP_UTEST_ASSERT_EQUALS(pCommand->getCommandName(), ipp::ScanOnCurve);
}

void ippCommandParserTestCase::testScanOnCurve_Format2_BadData()
{
  ippMemoryLeakDetector _leakDetector;
  ippCommandParser cmdParser;
  // form 2  - not well formed ( with wrong number of data )
  ippCommandPtr pCommand;
  cmdParser.setInput("00070 ScanOnCurve(Closed(0),"
                     "Format(X(),Y(),Z(),IJK(),tag,pi,pj,pk),"
                     "Data(1.,2.,3.,0.,0.,1.,3.,4.,5.,555,1.,2.,3.,0.,0.,1.,3.,4.,5.,666,99999,99999))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(BAD_NUMBER_OF_ARGUMENT_FOR_DATA_IN_SCANONCURVE,cmdParser.getParserErr());
}

void ippCommandParserTestCase::testScanOnCurve_Format3_OK()
{
  ippMemoryLeakDetector _leakDetector;
  ippCommandParser cmdParser;
  // form 3
  ippCommandPtr pCommand;
  cmdParser.setInput("00070 ScanOnCurve(Closed(0),"
                     "Format(X(),Y(),Z(),IJK(),tag,pi,pj,pk,si,sj,sk),"
                     "Data(1.,2.,3.,0.,0.,1.,3.,4.,5.,6.,7.,8.,555,1.,2.,3.,0.,0.,1.,3.,4.,5.,6.,7.,8.,666))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  if (!pCommand) return;
  IPP_UTEST_ASSERT_EQUALS(pCommand->getCommandName(), ipp::ScanOnCurve);
}

void ippCommandParserTestCase::testScanOnCurve_Format3_BadData()
{
  ippMemoryLeakDetector _leakDetector;
  ippCommandParser cmdParser;
  // form 3  - not well formed ( with wrong number of data )
  ippCommandPtr pCommand;
  cmdParser.setInput("00070 ScanOnCurve(Closed(0),"
                     "Format(X(),Y(),Z(),IJK(),tag,pi,pj,pk,si,sj,sk),"
                     "Data(1.,2.,3.,0.,0.,1.,3.,4.,5.,6.,7.,8.,555,1.,2.,3.,0.,0.,1.,3.,4.,5.,6.,7.,8.,666,99999,99999))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(!pCommand);
  IPP_UTEST_ASSERT_EQUALS(BAD_NUMBER_OF_ARGUMENT_FOR_DATA_IN_SCANONCURVE,cmdParser.getParserErr());
 }

void ippCommandParserTestCase::testScanOnCurve_Format1_very_long_input()
{
  ippMemoryLeakDetector _leakDetector;
  ippCommandParser cmdParser;
  // form 1
  ippCommandPtr pCommand;
  cmdParser.setInput("00070 ScanOnCurve(Closed(0),"
                     "Format(X(),Y(),Z(),IJK(),tag),"
                     "Data(1.,2.,3.,0.,0.,1.,555,"
                     "1.,2.,3.,0.,0.,1.,600,"
                     "1.,2.,3.,0.,0.,1.,601,"
                     "1.,2.,3.,0.,0.,1.,602,"
                     "1.,2.,3.,0.,0.,1.,603,"
                     "1.,2.,3.,0.,0.,1.,604,"
                     "1.,2.,3.,0.,0.,1.,605,"
                     "1.,2.,3.,0.,0.,1.,606,"
                     "1.,2.,3.,0.,0.,1.,607,"
                     "1.,2.,3.,0.,0.,1.,608,"
                     "1.,2.,3.,0.,0.,1.,609,"
                     "1.,2.,3.,0.,0.,1.,610,"
                     "1.,2.,3.,0.,0.,1.,611,"
                     "1.,2.,3.,0.,0.,1.,612,"
                     "1.,2.,3.,0.,0.,1.,613,"
                     "1.,2.,3.,0.,0.,1.,614,"
                     "1.,2.,3.,0.,0.,1.,615,"
                     "1.,2.,3.,0.,0.,1.,616,"
                     "1.,2.,3.,0.,0.,1.,617,"
                     "1.,2.,3.,0.,0.,1.,618,"
                     "1.,2.,3.,0.,0.,1.,619,"
                     "1.,2.,3.,0.,0.,1.,620,"
                     "1.,2.,3.,0.,0.,1.,621,"
                     "1.,2.,3.,0.,0.,1.,622,"
                     "1.,2.,3.,0.,0.,1.,623,"
                     "1.,2.,3.,0.,0.,1.,624,"
                     "1.,2.,3.,0.,0.,1.,625,"
                     "1.,2.,3.,0.,0.,1.,626,"
                     "1.,2.,3.,0.,0.,1.,627,"
                     "1.,2.,3.,0.,0.,1.,628,"
                     "1.,2.,3.,0.,0.,1.,629,"
                     "1.,2.,3.,0.,0.,1.,630,"
                     "1.,2.,3.,0.,0.,1.,631,"
                     "1.,2.,3.,0.,0.,1.,632,"
                     "1.,2.,3.,0.,0.,1.,633,"
                     "1.,2.,3.,0.,0.,1.,634,"
                     "1.,2.,3.,0.,0.,1.,635,"
                     "1.,2.,3.,0.,0.,1.,636,"
                     "1.,2.,3.,0.,0.,1.,637,"
                     "1.,2.,3.,0.,0.,1.,638,"
                     "1.,2.,3.,0.,0.,1.,639,"

                     "1.,2.,3.,0.,0.,1.,640,"
                     "1.,2.,3.,0.,0.,1.,641,"
                     "1.,2.,3.,0.,0.,1.,642,"
                     "1.,2.,3.,0.,0.,1.,643,"
                     "1.,2.,3.,0.,0.,1.,644,"
                     "1.,2.,3.,0.,0.,1.,645,"
                     "1.,2.,3.,0.,0.,1.,646,"
                     "1.,2.,3.,0.,0.,1.,647,"
                     "1.,2.,3.,0.,0.,1.,648,"
                     "1.,2.,3.,0.,0.,1.,649,"

                     "1.,2.,3.,0.,0.,1.,650,"
                     "1.,2.,3.,0.,0.,1.,651,"
                     "1.,2.,3.,0.,0.,1.,652,"
                     "1.,2.,3.,0.,0.,1.,653,"
                     "1.,2.,3.,0.,0.,1.,654,"
                     "1.,2.,3.,0.,0.,1.,655,"
                     "1.,2.,3.,0.,0.,1.,656,"
                     "1.,2.,3.,0.,0.,1.,657,"
                     "1.,2.,3.,0.,0.,1.,658,"
                     "1.,2.,3.,0.,0.,1.,659,"

                     "1.,2.,3.,0.,0.,1.,666))"IPP_END_STRING);
  cmdParser.parseTag();
  IPP_UTEST_ASSERT_EQUALS(cmdParser.getTag(), 70);
  pCommand = cmdParser.parseCommand();
  IPP_UTEST_ASSERT(pCommand);
  if (!pCommand) return;
  IPP_UTEST_ASSERT_EQUALS(pCommand->getCommandName(), ipp::ScanOnCurve);
}






#include <fstream>
bool _verbose = false;
void TestCommandsOnFile(
  LPCTSTR filename,
  int expected_parsing_error = 0
 )
{

  int counter = 0;
  
  const int IPP_MAXSTRINGSIZE = 65535;
  char buf[IPP_MAXSTRINGSIZE];
 
  //xx std::cout << "parsing file : " << filename  << std::endl;

  std::ifstream input;
  input.open(filename);
  IPP_UTEST_ASSERT(!input.bad());
  if (input.bad()) return;
  int line =0;
  while(!input.eof()) {
    std::string str;
    input.getline(buf,IPP_MAXSTRINGSIZE);

    line++;
    size_t l = strlen(buf);
    buf[l] =13;
    buf[l+1] =10;
    buf[l+2] =0;

    str = buf;
    if (str.find("\\")==0 || str.find(":")==0 || str.length()==2) {
    } else {

      ippMemoryLeakDetector _leakDetector;

      ippCommandParser cmdParser;

      cmdParser.setInput(str.c_str());
      ippCommandPtr command = cmdParser.parseCommand();
      
      if (expected_parsing_error>0){ 
        if (!command.get()) {
          counter++; // we just want to record  the number of failure in this case
          // 
          if (0 && _verbose) {
            std::cout << filename <<"(" << line << ")"  << std::endl;
            std::cout << " parsing  : " << str.c_str() << std::endl;
            std::cout << " Error    : " << cmdParser.getErrorMessageString() << std::endl;
          }
        } else {
          if (command->getCommandName() !=ClearAllErrors && _verbose) { 
            std::cout << filename <<"(" << line << ")"  << std::endl;
            std::cout << " parsing  : " << str.c_str() << std::endl;
            std::cout << " Error    : " << cmdParser.getErrorMessageString() << std::endl;
          }
        }
      } else {
        IPP_UTEST_ASSERT(command.get());
        if (!command.get()) {
          // 
          std::cout << filename <<"(" << line << ")"  << std::endl;
          std::cout << " parsing  : " << str.c_str() << std::endl;
          std::cout << " Error    : " << cmdParser.getErrorMessageString() << std::endl;
        }
    }

    }
  }
  if (expected_parsing_error) { 
    IPP_UTEST_ASSERT_EQUALS(expected_parsing_error,counter);
    if (counter!= expected_parsing_error ){ 
      std::cout << filename <<"(" << line << ")"  << std::endl;
    }
 }
}



void ippCommandParserTestCase::testOnSamplePRGFileI()
{
  
  ippTestFolder folder;
  bool bSuccess = folder.find_first_file(test_file_folder().c_str(),"*.prg");
  IPP_UTEST_ASSERT(bSuccess);
  
  while(bSuccess) {
    
    std::string filename = folder.current_filename();
    
    if (filename.find("checkerCmdErrors.prg")!=std::string::npos ) { 
      TestCommandsOnFile(filename.c_str(),1);
    }  else if (filename.find("parserCmdErrors.prg")!=std::string::npos  ) { 
      TestCommandsOnFile(filename.c_str(),260); 
    } else if (filename.find("numbersErrorCmd.prg")!=std::string::npos  ) { 
      TestCommandsOnFile(filename.c_str(),7);
    } else {
      TestCommandsOnFile(filename.c_str());
    }
    
    bSuccess = folder.next();
  }
}

---