ippResponseParserTestCase.cpp

Go to the documentation of this file.

#include "ippResponseParserTestCase.h"
#include "ippdme/Parser/ippResponseParser.h"
#include "ippdme/Response/ippSetPropEResponse.h"
#include "ippdme/Response/ippGetPropResponse.h"
#include "ippTestFolder.h"
#include "ippMemoryLeakDetector.h"
#include <fstream>

CXXTEST_ENUM_TRAITS( ippResponseNameType,
                     CXXTEST_ENUM_MEMBER( ippResponseNameType_ERROR)
                     CXXTEST_ENUM_MEMBER( Ack )
                     CXXTEST_ENUM_MEMBER( Complete )
                     CXXTEST_ENUM_MEMBER( DataAlign )
                     CXXTEST_ENUM_MEMBER( DataCenterPart )
                     CXXTEST_ENUM_MEMBER( DataChangeToolE )
                     CXXTEST_ENUM_MEMBER( DataEnumProp )
                     CXXTEST_ENUM_MEMBER( DataGetChangeToolAction )
                     CXXTEST_ENUM_MEMBER( DataGetCoordSystem )
                     CXXTEST_ENUM_MEMBER( DataGetCsyTransformation )
                     CXXTEST_ENUM_MEMBER( DataGetDMEVersion )
                     CXXTEST_ENUM_MEMBER( DataGetErrStatusE )
                     CXXTEST_ENUM_MEMBER( DataGetMachineClass )
                     CXXTEST_ENUM_MEMBER( DataGetProp )
                     CXXTEST_ENUM_MEMBER( DataGoToE )
                     CXXTEST_ENUM_MEMBER( DataIsHomed )
                     CXXTEST_ENUM_MEMBER( DataIsUserEnabled )
                     CXXTEST_ENUM_MEMBER( DataKeyPressE )
                     CXXTEST_ENUM_MEMBER( DataOnMoveReportE )
                     CXXTEST_ENUM_MEMBER( DataPtMeasOrGet )
                     CXXTEST_ENUM_MEMBER( DataPtMeasE )
                     CXXTEST_ENUM_MEMBER( DataScan )
                     CXXTEST_ENUM_MEMBER( DataSetPropE )
                     CXXTEST_ENUM_MEMBER( DataString )
                     CXXTEST_ENUM_MEMBER( DataTiltCenterPart )
                     CXXTEST_ENUM_MEMBER( DataTiltPart )
                     CXXTEST_ENUM_MEMBER( ErrorError )
                     CXXTEST_ENUM_MEMBER( ippResponseNameType_MAXVALUE));

void TestResponsesOnFile(
  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;

  while(!input.eof()) {

    std::string str;
    input.getline(buf,IPP_MAXSTRINGSIZE);

    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;

      ippResponseParser responseParser;

      responseParser.setInput(str.c_str());
      ippResponsePtr response = responseParser.parseResponse();
      
      if (expected_parsing_error>0){ 
        if (!response.get()) {
          counter++; // we just want to record  the number of failure in this case
        } else {
          //xx if(response->getResponseName() != Ack && response->getResponseName() != Complete) {
          //xx   std::cout << " success with " << str.c_str() << std::endl; 
          //xx }
        }
      } else {
        IPP_UTEST_ASSERT(response.get());
        if (!response.get()) {
          // 
          std::cout << " filename : " << filename << std::endl;
          std::cout << " parsing  : " << str.c_str() << std::endl;
          std::cout << " Error    : " << responseParser.getErrorMessageString() << std::endl;
        }
    }

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

void ippResponseParserTestCase::testOnSampleResFile()
{
  ippTestFolder folder;
  bool bSuccess = folder.find_first_file(test_file_folder().c_str(),"*.res");
  IPP_UTEST_ASSERT(bSuccess);

  while(bSuccess) {
    
    std::string filename = folder.current_filename();

    if (filename.find("checkerCmdErrors.res")!=std::string::npos ) { 
      TestResponsesOnFile(filename.c_str(),12);
    }  else if (filename.find("parserResErrors.res")!=std::string::npos  ) { 
      TestResponsesOnFile(filename.c_str(),129);
    } else if (filename.find("numbersErrorCmd.res")!=std::string::npos  ) { 
      TestResponsesOnFile(filename.c_str(),7);
    } else if (filename.find("numbersErrorRes.res")!=std::string::npos  ) { 
      TestResponsesOnFile(filename.c_str(),7);
    } else {
      TestResponsesOnFile(filename.c_str());
    }

    bSuccess = folder.next();
  }

}

void ippResponseParserTestCase::testOnMoveReportE()
{
  ippMemoryLeakDetector _leakDetector;

  ippResponseParser responseParser;

  responseParser.setInput("E0010 # R(0),X(1),Y(2),Z(3),Tool.A(4),Tool.B(5),Tool.C(6)\r\n");
  ippResponsePtr response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(response.get());
  IPP_UTEST_ASSERT_EQUALS(DataOnMoveReportE,response->getResponseName());
  
}

void ippResponseParserTestCase::testOnMoveReportE_bad_string()
{
  ippMemoryLeakDetector _leakDetector;

  ippResponseParser responseParser;
  // the input string has a unexpected comma at the end : parsing should fail
  responseParser.setInput("E0010 # X(3), Y(4) ,\r\n");
  ippResponsePtr response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(!response.get());
  
  // the input string has no comma between the two arguments
  responseParser.setInput("E0010 # X(3) Y(4)\r\n");
  response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(!response.get());
}

void ippResponseParserTestCase::testPtMeas()
{
  ippMemoryLeakDetector _leakDetector;

  ippResponseParser responseParser;

  responseParser.setInput("E0000 # PtMeas(Z(+.197),X(-2.6),Y(0.78),Tool.A(90),Tool.B(0),Tool.C(0),ER(4))\r\n");
  ippResponsePtr response = responseParser.parseResponse();
  IPP_UTEST_ASSERT_EQUALS(DataPtMeasE,response->getResponseName());
  IPP_UTEST_ASSERT(response.get());
}

void ippResponseParserTestCase::testSetPropEResponse()
{
  ippMemoryLeakDetector _leakDetector;
  ippResponseParser responseParser;

  responseParser.setInput("E0000 # SetProp(Tool.GoToPar.Speed(55))\r\n");
  ippResponsePtr response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(response.get());
  IPP_UTEST_ASSERT_EQUALS(DataSetPropE,response->getResponseName());
  
  responseParser.setInput("E0000 # SetProp(Tool.GoToPar.Speed.Act(55))\r\n");
  response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(response.get());
  IPP_UTEST_ASSERT_EQUALS(DataSetPropE,response->getResponseName());

  responseParser.setInput("E0000 # SetProp(Part.Temperature(55))\r\n");
  response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(response.get());
  IPP_UTEST_ASSERT_EQUALS(DataSetPropE,response->getResponseName());

}

void ippResponseParserTestCase::testSetPropEResponseMulti()
{
  ippMemoryLeakDetector _leakDetector;
  ippResponseParser responseParser;

  responseParser.setInput("E0000 # SetProp(Tool.GoToPar.Speed(55), Part.Temperature(55), Tool.PtMeasPar.Accel(45.))\r\n");
  ippResponsePtr response = responseParser.parseResponse();
  
  IPP_UTEST_ASSERT(response.get());
  IPP_UTEST_ASSERT_EQUALS(DataSetPropE,response->getResponseName());

  ippSetPropEResponseConstPtr r = static_cast<ippSetPropEResponse*>(response.get());
  IPP_UTEST_ASSERT_EQUALS(3,r->getNumberProps());

}

void ippResponseParserTestCase::testSetPropEResponse_bad_string()
{
  ippMemoryLeakDetector _leakDetector;

  ippResponseParser responseParser;
  // the input string has a missing closing parenthesis at the end=> parsing should fail
  responseParser.setInput("E0000 # SetProp(Tool.GoToPar.Speed.Act(2)\r\n");
  ippResponsePtr response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(!response.get());

  responseParser.setInput("E0000 # SetProp(Tool.GoToPar.Speed.Act(2)FoundTool.GoToPar.Speed.Act(2))\r\n");
  response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(!response.get());

  responseParser.setInput("E0000 # SetProp(Tool.GoToPar.Speed.Act(2),FoundTool.GoToPar.Speed.Act(2)\r\n");
  response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(!response.get());
}

void ippResponseParserTestCase::testToolCollisionVolume()
{

  ippMemoryLeakDetector _leakDetector;

  ippResponseParser responseParser;
  responseParser.setInput("00090 # Tool.CollisionVolume(OBB,150,10,530,50,50,500, 1,0,0, 0,1,0, 0,0,1)\r\n");
  ippResponsePtr response = responseParser.parseResponse();
  IPP_UTEST_ASSERT(response.get());
   

}

---