ippResponseTestCase.cpp

Go to the documentation of this file.

#include "ippResponseTestCase.h"

#include "ippdme/Misc/ippStringBuilder.h"
#include "ippdme/Response/ippAckResponse.h"
#include "ippdme/Response/ippCenterPartResponse.h"
#include "ippdme/Response/ippAlignResponse.h"
#include "ippdme/Response/ippChangeToolEResponse.h"
#include "ippdme/Response/ippEnumPropResponse.h"
#include "ippdme/Response/ippErrorResponse.h"
#include "ippdme/Response/ippGetChangeToolActionResponse.h"
#include "ippdme/Response/ippGetCoordSystemResponse.h"
#include "ippdme/Response/ippGetCsyTransformationResponse.h"
#include "ippdme/Response/ippGetDMEVersionResponse.h"
#include "ippdme/Response/ippGetErrStatusEResponse.h"
#include "ippdme/Response/ippGetMachineClassResponse.h"
#include "ippdme/Response/ippGetPropResponse.h"
#include "ippdme/Response/ippGoToEResponse.h"
#include "ippdme/Response/ippIsHomedResponse.h"
#include "ippdme/Response/ippIsUserEnabledResponse.h"
#include "ippdme/Response/ippKeyPressEResponse.h"
#include "ippdme/Response/ippOnMoveReportEResponse.h"
#include "ippdme/Response/ippPtMeasEResponse.h"
#include "ippdme/Response/ippPtMeasOrGetResponse.h"
#include "ippdme/Response/ippScanResponse.h"
#include "ippdme/Response/ippSetPropEResponse.h"
#include "ippdme/Response/ippStringResponse.h"
#include "ippdme/Response/ippTiltCenterPartResponse.h"
#include "ippdme/Response/ippTiltPartResponse.h"

#include "ippdme/Property/ippOnePropertyNumber.h"

#include "ippdme/Parser/ippResponseParser.h"

#include "ippMemoryLeakDetector.h"

void recheck_with_parser(ippResponse& r,bool bParsingShouldFail = false)
{
  ippMemoryLeakDetector _leakDetector;
  ippResponseParser parser;
  std::string t = r.getResponseString();
  parser.setInput(t.c_str());
  
  ippResponsePtr r_check= parser.parseResponse();
  if (bParsingShouldFail) {
    IPP_UTEST_ASSERT(!r_check);
    if(r_check) {
      std::cout << " parsing should have failed : " << std::endl << t << std::endl;
      std::cout << parser.getErrorMessageString() <<std::endl;
    }
    return ;  
  }
  if (r_check) {
    std::string t_check = r_check->getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,t_check);
  } else {
    // parsing has failed why ?
    IPP_UTEST_ASSERT_M(std::string(" failing parsing \n")+t  ,r_check);
    std::cout << " failing parsing " << std::endl << t << std::endl;
    std::cout << parser.getErrorMessageString() <<std::endl;
  }

}

void ippResponseTestCase::testAckResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    ippAckResponse r(100, CommandTag);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00100 &"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippAckResponse r(100, EventTag);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0100 &"IPP_END_STRING);
    recheck_with_parser(r);

  }

}

void ippResponseTestCase::testAlignResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    ippAlignResponse r(65,10.,20.,40.,11.,21.,41.);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00065 # (10., 20., 40., 11., 21., 41.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippAlignResponse r(65,10.,20.,40.);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00065 # (10., 20., 40.)"IPP_END_STRING);
    recheck_with_parser(r);

  }

}
void ippResponseTestCase::testCenterPartResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    ippCenterPartResponse r(65,true);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00065 # CenterPart(1)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippCenterPartResponse r(65,false);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00065 # CenterPart(0)"IPP_END_STRING);
    recheck_with_parser(r);
  }

}
#define QUOTE(a) "\""a"\""

void ippResponseTestCase::testChangeToolEResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    ippChangeToolEResponse r("MyTool");
    std::string t = r.getResponseString();
    
    const std::string expected_String="E0000 # ChangeTool(\"MyTool\")"IPP_END_STRING;

    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
  {
    ippChangeToolEResponse r;
    std::string t = r.getResponseString();
    const std::string expected_String="E0000 # ChangeTool(\"\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }

}


void ippResponseTestCase::testEnumPropResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    ippEnumPropResponse r(1234,"SomeProp","SomeValue");
    std::string t = r.getResponseString();
    const std::string expected_String="01234 # \"SomeProp\", \"SomeValue\""IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
}
void ippResponseTestCase::testErrorResponse()
{
  // Note according to the I++ standard the 3 argument should be a keyword
  // not a string, but this is only valid for errors that are
  // also the I++ standard only "recommend" to use a keyword, why not imposed ?
  // can it be a string as well ?
  // the NIST test suite up to version 3.0 was producing a string here.
  ippMemoryLeakDetector _leakDetector;
  {
    ippErrorResponse r(25,CommandTag,ProtocolError,"reason");
    std::string t = r.getResponseString();
    const std::string expected_String="00025 ! Error(3, 0008, \"reason\", \"Protocol error\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
  // check that ippErrorResponse remove unwanted char in error description
  {
    ippErrorResponse r(25,CommandTag,ProtocolError,"\t\"\"");
    std::string t = r.getResponseString();
    const std::string expected_String="00025 ! Error(3, 0008, \"?##\", \"Protocol error\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
  // check that ippErrorResponse remove unwanted char in error description
  {
    ippErrorResponse r(54,CommandTag,UseClearAllErrorsToCont,"Get");
    std::string t = r.getResponseString();
    const std::string expected_String="00054 ! Error(2, 0514, \"Get\", \"Use ClearAllErrors to continue\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
}

void ippResponseTestCase::testGetChangeToolActionResponse()
{
  ippMemoryLeakDetector _leakDetector;

  ippGetChangeToolActionResponse r(25,MoveAuto,10.,20.,30.);
  std::string t = r.getResponseString();
  IPP_UTEST_ASSERT_EQUALS(t,"00025 # ChangeToolAction(MoveAuto, X(10.), Y(20.), Z(30.))"IPP_END_STRING);
    recheck_with_parser(r);
}

void ippResponseTestCase::testGetCoordSystemResponse()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippGetCoordSystemResponse r(25,MachineCsy);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # CoordSystem(MachineCsy)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippGetCoordSystemResponse r(25,MoveableMachineCsy);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # CoordSystem(MoveableMachineCsy)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippGetCoordSystemResponse r(25,MultipleArmCsy);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # CoordSystem(MultipleArmCsy)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippGetCoordSystemResponse r(25,PartCsy);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # CoordSystem(PartCsy)"IPP_END_STRING);
    recheck_with_parser(r);
  }

  {
    ippGetCoordSystemResponse r(25,JogDisplayCsy);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # CoordSystem(JogDisplayCsy)"IPP_END_STRING);
    recheck_with_parser(r, /*should_fail =*/true);
  }
  {
    ippGetCoordSystemResponse r(25,JogMoveCsy);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # CoordSystem(JogMoveCsy)"IPP_END_STRING);
    recheck_with_parser(r,/*should_fail =*/true);
  }
  {
    ippGetCoordSystemResponse r(25,SensorCsy);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # CoordSystem(SensorCsy)"IPP_END_STRING);
    recheck_with_parser(r,/*should_fail =*/true);
  }


}

void ippResponseTestCase::testGetCsyTransformationResponse()
{
  ippMemoryLeakDetector _leakDetector;

  ippGetCsyTransformationResponse r(25, 10.,20.,30., 45.,60.,90.);
  std::string t = r.getResponseString();
  IPP_UTEST_ASSERT_EQUALS(t,"00025 # GetCsyTransformation(10., 20., 30., 45., 60., 90.)"IPP_END_STRING);
  recheck_with_parser(r);

}
void ippResponseTestCase::testGetDMEVersionResponse()
{
  ippMemoryLeakDetector _leakDetector;

  ippGetDMEVersionResponse r(25,"1.4.0");
  std::string t = r.getResponseString();
  const std::string expected_String="00025 # DMEVersion(\"1.4.0\")"IPP_END_STRING;
  IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);


}

void ippResponseTestCase::testGetErrStatusEResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    ippGetErrStatusEResponse r(25,true);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0025 # ErrStatus(1)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippGetErrStatusEResponse r(25,false);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0025 # ErrStatus(0)"IPP_END_STRING);
    recheck_with_parser(r);
  }
}
void ippResponseTestCase::testGetMachineClassResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    ippGetMachineClassResponse r(25,CartCMMWithRotaryTable);
    std::string t = r.getResponseString();
    const std::string expected_String="00025 # GetMachineClass(CartCMMWithRotaryTable)"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
  {
    ippGetMachineClassResponse r(25,CartCMM);
    std::string t = r.getResponseString();
    const std::string expected_String="00025 # GetMachineClass(CartCMM)"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }

}

void ippResponseTestCase::testGetPropResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    const int N_PROP = 1;
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyNumber(ippProp(Tool,GoToPar,Accel), 12.5));

    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # Tool.GoToPar.Accel(12.5)"IPP_END_STRING);
    recheck_with_parser(r);
    }
  {
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyNumber(ippProp(Tool,GoToPar,Speed), 1.5));
    r.append(new ippOnePropertyNumber(ippProp(Tool,GoToPar,Speed), 120.5));
    r.append(new ippOnePropertyNumber(ippProp(FoundTool,GoToPar,Speed,Min),12.5));

    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # Tool.GoToPar.Speed(1.5), Tool.GoToPar.Speed(120.5), FoundTool.GoToPar.Speed.Min(12.5)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyNumber(ippProp(Part,Temperature),12.5));
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # Part.Temperature(12.5)"IPP_END_STRING);
    recheck_with_parser(r);
  }
}
void ippResponseTestCase::testGoToEResponse()
{
  ippMemoryLeakDetector _leakDetector;

  /* bool inHasER, bool inHasIJK, bool inHasR,
                bool inHasToolA, bool inHasToolB, bool inHasToolC,
                bool inHasX, bool inHasY, bool inHasZ, double inTheER,
                double inR, double inToolA, double inToolB, double inToolC,
                double inX, double inY, double inZ):
  */
  {
    ippGoToEResponse r(
         true/*ER*/,false/*IJK*/,false/*hasR*/,
         false/*toolA*/,false/*toolB*/,false/*toolC*/,
         false/*hasX*/,false/*hasY*/,false/*hasZ*/,
            10.0,1.0,15.0,45.0,0.0,11.,12.,13.0);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0000 # GoTo(ER(10.))"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippGoToEResponse r(
         true/*ER*/,false/*IJK*/,false/*hasR*/,
         true/*toolA*/,false/*toolB*/,false/*toolC*/,
         false/*hasX*/,false/*hasY*/,false/*hasZ*/,
            10.0,1.0,15.0,45.0,0.0,11.,12.,13.0);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0000 # GoTo(ER(10.), Tool.A(15.))"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippGoToEResponse r(
         true/*ER*/,false/*IJK*/,false/*hasR*/,
         true/*toolA*/,true/*toolB*/,false/*toolC*/,
         false/*hasX*/,false/*hasY*/,false/*hasZ*/,
            10.0,1.0,15.0,45.0,0.0,11.,12.,13.0);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0000 # GoTo(ER(10.), Tool.A(15.), Tool.B(45.))"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippGoToEResponse r(
         false/*ER*/,false/*IJK*/,false/*hasR*/,
         false/*toolA*/,false/*toolB*/,false/*toolC*/,
         true/*hasX*/,true/*hasY*/,true/*hasZ*/,
            10.0,1.0,15.0,45.0,0.0,11.,12.,13.0);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0000 # GoTo(X(11.), Y(12.), Z(13.))"IPP_END_STRING);
    recheck_with_parser(r);
  }
}

void ippResponseTestCase::testIsHomedResponse()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippIsHomedResponse r(25,true);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # IsHomed(1)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippIsHomedResponse r(25,false);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # IsHomed(0)"IPP_END_STRING);
    recheck_with_parser(r);
  }
}
void ippResponseTestCase::testIsUserEnabledResponse()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippIsUserEnabledResponse r(25,true);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # IsUserEnabled(1)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippIsUserEnabledResponse r(25,false);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # IsUserEnabled(0)"IPP_END_STRING);
    recheck_with_parser(r);
  }
}

void ippResponseTestCase::testKeyPressEResponse()
{
  ippMemoryLeakDetector _leakDetector;
  
  {
    ippKeyPressEResponse r("A");
    std::string t = r.getResponseString();
    const std::string expected_String="E0000 # KeyPress(\"A\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
  {
    ippKeyPressEResponse r("F2");
    std::string t = r.getResponseString();
    const std::string expected_String="E0000 # KeyPress(\"F2\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
}
void ippResponseTestCase::testOnMoveReportEResponse()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippOnMoveReportEResponse r(25);
    r.setHasX(true);r.setX(10.0);
    r.setHasZ(true);r.setZ(13.0);

    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0025 # X(10.), Z(13.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippOnMoveReportEResponse r(25);
    r.setHasX(true);r.setX(10.0);
    r.setHasZ(true);r.setZ(13.0);
    r.setHasToolA(true);r.setToolA(35.0);
    r.setHasToolB(true);r.setToolB(45.0);

    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"E0025 # X(10.), Z(13.), Tool.A(35.), Tool.B(45.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
}


// ippPtMeasEResponse
void ippResponseTestCase::testPtMeasEResponse()
{
  ippMemoryLeakDetector _leakDetector;

  ippPtMeasEResponse r;
  r.setHasX(true);r.setX(10.0);
  r.setHasZ(true);r.setZ(13.0);
  r.setHasIJK(true);r.setIJK(1.,0.,0.0);

  std::string t = r.getResponseString();
  IPP_UTEST_ASSERT_EQUALS(t,"E0000 # PtMeas(IJK(1., 0., 0.), X(10.), Z(13.))"IPP_END_STRING);
  recheck_with_parser(r);

}
// ippPtMeasOrGetResponse
void ippResponseTestCase::testPtMeasOrGetResponse()
{
  ippMemoryLeakDetector _leakDetector;
  
  {
    ippPtMeasOrGetResponse r(25);
    r.setHasX(true);r.setX(10.0);
    r.setHasZ(true);r.setZ(13.0);
    r.setHasIJK(true);r.setIJK(1.,0.,0.0);
    r.setHasER(true);r.setER(1.0);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # IJK(1., 0., 0.), ER(1.), X(10.), Z(13.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippPtMeasOrGetResponse r(25);
    r.setHasQ(true);r.setQ(100.0);
    r.setHasIJK(true);r.setIJK(1.,0.,0.0);
    r.setHasER(true);r.setER(1.0);
    r.setHasIJKAct(true);r.setIJKAct(1);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # IJK(1., 0., 0.), IJKAct(1), ER(1.), Q(100.)"IPP_END_STRING);
    recheck_with_parser(r);
  }

}
// ippScanResponse
void ippResponseTestCase::testScanResponse()
{
  ippMemoryLeakDetector _leakDetector;

  ippScanResponse r(25);
  double d[] ={ 1.,2.,3.,4.,5.,6.,7.};
  r.setData(sizeof(d)/sizeof(d[0]),d);

  std::string t = r.getResponseString();

  IPP_UTEST_ASSERT_EQUALS(t,"00025 # 1., 2., 3., 4., 5., 6., 7."IPP_END_STRING);
  recheck_with_parser(r);
}
// ippSetPropEResponse
void ippResponseTestCase::testSetPropEResponse()
{
  ippMemoryLeakDetector _leakDetector;

  ippSetPropEResponse r;
  r.addPropValue(ippProp(FoundTool,PtMeasPar,Speed,Actual),1.0);

  std::string t = r.getResponseString();
  IPP_UTEST_ASSERT_EQUALS(t,"E0000 # SetProp(FoundTool.PtMeasPar.Speed.Act(1.))"IPP_END_STRING);
  recheck_with_parser(r);

}
void ippResponseTestCase::testSetPropEResponseMulti()
{
  ippMemoryLeakDetector _leakDetector;

  ippSetPropEResponse r;
  r.addPropValue(ippProp(FoundTool,PtMeasPar,Speed,Actual),1.0);
  // illegal use Get: r.addPropValue(ippProp(Tool,_A),45.0);
  r.addPropValue(ippProp(FoundTool,GoToPar,Speed),10.0);

  std::string t = r.getResponseString();
  IPP_UTEST_ASSERT_EQUALS(t,"E0000 # SetProp(FoundTool.PtMeasPar.Speed.Act(1.), FoundTool.GoToPar.Speed(10.))"IPP_END_STRING);
  recheck_with_parser(r);

}
// ippStringResponse
void ippResponseTestCase::testStringResponse()
{ 
  ippMemoryLeakDetector _leakDetector;

  ippStringResponse r(25,"SomeString");
  std::string t = r.getResponseString();
  const std::string expected_String="00025 # \"SomeString\""IPP_END_STRING;
  IPP_UTEST_ASSERT_EQUALS(t,expected_String);
  recheck_with_parser(r);
}
// ippTiltCenterPartResponse
void ippResponseTestCase::testTiltCenterPartResponse()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippTiltCenterPartResponse r(25,true);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # TiltCenterPart(1)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippTiltCenterPartResponse r(25,false);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # TiltCenterPart(0)"IPP_END_STRING);
    recheck_with_parser(r);
  }
}

// ippTiltPartResponse
void ippResponseTestCase::testTiltPartResponse()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippTiltPartResponse r(25,true);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # TiltPart(1)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    ippTiltPartResponse r(25,false);
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # TiltPart(0)"IPP_END_STRING);
    recheck_with_parser(r);
  }

}

void ippResponseTestCase::testToolAlignmentResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    // check the answer provided in response to a
    // GetProp(Tool.Alignment()) command
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyAlignment(Tool,1.,2.0,3.0));
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # Tool.Alignment(1., 2., 3.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    // check the answer provided in response to a
    // GetProp(Tool.Alignment()) command with variation 2
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyAlignment(Tool,1.,2.0,3.0,4.0,5.0,6.0));
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # Tool.Alignment(1., 2., 3., 4., 5., 6.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    // check the answer provided in response to a
    // GetProp(FoundTool.Alignment()) command
    // NOTE : THE STANDARD is not clear whether the return string should be FoundTool.Alignment 
    //        or Tool.Alignment as well.The assumption is made that FoundTool should be returned
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyAlignment(FoundTool,1.,2.0,3.0));
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # FoundTool.Alignment(1., 2., 3.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    // check the answer provided in response to a
    // GetProp(Tool.Alignment()) command
    // NOTE : THE STANDARD is not clear whether the return string should be FoundTool.Alignment 
    //        or Tool.Alignment as well.
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyAlignment(FoundTool,1.,2.0,3.0,4.0,5.0,6.0));
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # FoundTool.Alignment(1., 2., 3., 4., 5., 6.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
}

void ippResponseTestCase::testToolAlignmentVolumeResponse()
{
  ippMemoryLeakDetector _leakDetector;
  {
    // check the answer provided in response to a
    // GetProp(Tool.AlignmentVolume()) command
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyAlignmentVolume(Tool,1.,2.0,3.0,4.0));
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # Tool.AlignmentVolume(SPH, 1., 2., 3., 4.)"IPP_END_STRING);
    recheck_with_parser(r);
  }
  {
    // check the answer provided in response to a
    // GetProp(FoundTool.AlignmentVolume()) command
    // NOTE : THE STANDARD is not clear whether the return string should be FoundTool.Alignment 
    //        or Tool.Alignment as well.The assumption is made that FoundTool should be returned
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyAlignmentVolume(FoundTool,1.,2.0,3.0,4.0));
    std::string t = r.getResponseString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 # FoundTool.AlignmentVolume(SPH, 1., 2., 3., 4.)"IPP_END_STRING);
    recheck_with_parser(r);
  }

}
void ippResponseTestCase::testToolIdResponse()
{
 ippMemoryLeakDetector _leakDetector;
  {
    // check the answer provided in response to a
    // GetProp(Tool.Id()) command
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyId(Tool,"<somexml/>"));
    std::string t = r.getResponseString();
     const std::string expected_String="00025 # Tool.Id(\"<somexml/>\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
  {
    // since 1.41 see 6.3.11

    // check the answer provided in response to a
    // GetProp(FoundTool.Id()) command
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyId(FoundTool,"<somexml/>"));
    std::string t = r.getResponseString();
    const std::string expected_String="00025 # FoundTool.Id(\"<somexml/>\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
}
void ippResponseTestCase::testToolNameResponse()
{
 ippMemoryLeakDetector _leakDetector;
  {
    // check the answer provided in response to a
    // GetProp(Tool.Name()) command
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyName(Tool,"blah"));
    std::string t = r.getResponseString();
    const std::string expected_String="00025 # Tool.Name(\"blah\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
  { 
    // since 1.41 see 6.3.10

    // check the answer provided in response to a
    // GetProp(FoundTool.Name()) command
    ippGetPropResponse r(25,CommandTag);
    r.append(new ippOnePropertyName(FoundTool,"blah"));
    std::string t = r.getResponseString();
    const std::string expected_String="00025 # FoundTool.Name(\"blah\")"IPP_END_STRING;
    IPP_UTEST_ASSERT_EQUALS(t,expected_String);
    recheck_with_parser(r);
  }
}

#include "ippdme/misc/ippPropDefinition.h"
void ippResponseTestCase::testfindPropertyDefinition()
{
  const ippPropDefinition* d1 =  findPropertyDefinition( ippProp(FoundTool));
  IPP_UTEST_ASSERT(d1 && d1->_keyword == FoundTool);
  const ippPropDefinition* d2 =  findPropertyDefinition( ippProp(Tool));
  IPP_UTEST_ASSERT(d2 && d2->_keyword == Tool);
  const ippPropDefinition* d3 =  findPropertyDefinition( ippProp(Part));
  IPP_UTEST_ASSERT(d3 && d3->_keyword == Part);
  const ippPropDefinition* d4 =  findPropertyDefinition( ippProp(FoundTool,Id));
  IPP_UTEST_ASSERT(d4 && d4->_keyword == Id);
  const ippPropDefinition* d5 =  findPropertyDefinition( ippProp(Tool,PtMeasPar));
  IPP_UTEST_ASSERT(d5 && d5->_keyword == PtMeasPar);
  const ippPropDefinition* d6 =  findPropertyDefinition( ippProp(Part,Temperature));
  IPP_UTEST_ASSERT(d6 && d6->_keyword == Temperature);

}

#include "ippdme/Command/ippEnumAllPropCommand.h"
void ippResponseTestCase::testGenerateEnumAllPropResponses()
{
  {
    ippEnumAllPropCommandConstPtr cmd = new ippEnumAllPropCommand(25,ippProp(FoundTool,PtMeasPar));
    ippResponseList  list;
    GenerateEnumAllPropResponses(cmd,list);
    if (0) {
      std::cout << " command : " << cmd->getCommandString() << std::endl;
      for (ippResponseList::iterator p = list.begin();p!=list.end();p++)  {
        std::cout << " " << (*p)->getResponseString() << std::endl;    
      }
    }

    std::string t [] ={ 
      "00025 # \"Speed\", \"Property\"\r\n",
      "00025 # \"Speed\", \"Number\"\r\n",
      "00025 # \"Speed.Act\", \"Number\"\r\n",
      "00025 # \"Speed.Def\", \"Number\"\r\n",
      "00025 # \"Speed.Max\", \"Number\"\r\n",
      "00025 # \"Speed.Min\", \"Number\"\r\n",
      "00025 # \"Accel\", \"Property\"\r\n",
      "00025 # \"Accel\", \"Number\"\r\n",
      "00025 # \"Accel.Act\", \"Number\"\r\n",
      "00025 # \"Accel.Def\", \"Number\"\r\n",
      "00025 # \"Accel.Max\", \"Number\"\r\n",
      "00025 # \"Accel.Min\", \"Number\"\r\n",
      "00025 # \"Approach\", \"Property\"\r\n",
      "00025 # \"Approach\", \"Number\"\r\n",
      "00025 # \"Approach.Act\", \"Number\"\r\n",
      "00025 # \"Approach.Def\", \"Number\"\r\n",
      "00025 # \"Approach.Max\", \"Number\"\r\n",
      "00025 # \"Approach.Min\", \"Number\"\r\n",
      "00025 # \"Retract\", \"Property\"\r\n",
      "00025 # \"Retract\", \"Number\"\r\n",
      "00025 # \"Retract.Act\", \"Number\"\r\n",
      "00025 # \"Retract.Def\", \"Number\"\r\n",
      "00025 # \"Retract.Max\", \"Number\"\r\n",
      "00025 # \"Retract.Min\", \"Number\"\r\n",
      "00025 # \"Search\", \"Property\"\r\n",
      "00025 # \"Search\", \"Number\"\r\n",
      "00025 # \"Search.Act\", \"Number\"\r\n",
      "00025 # \"Search.Def\", \"Number\"\r\n",
      "00025 # \"Search.Max\", \"Number\"\r\n",
      "00025 # \"Search.Min\", \"Number\"\r\n",
    };
    {
      size_t nb = sizeof(t)/sizeof(t[0]);
      IPP_UTEST_ASSERT_EQUALS(list.size(),nb);
      for (size_t i=0;i<std::min(nb,list.size());i++)  {
        IPP_UTEST_ASSERT_EQUALS(list[i]->getResponseString(),t[i]);
      }
    }
    


  }
  {
    ippEnumAllPropCommandConstPtr cmd = new ippEnumAllPropCommand(25,ippProp(FoundTool));
    ippResponseList  list;
    GenerateEnumAllPropResponses(cmd,list); 
    if (0) {
      std::cout << " command : " << cmd->getCommandString() << std::endl;
      for (ippResponseList::iterator p = list.begin();p!=list.end();p++)  {
         std::cout << " " << (*p)->getResponseString() << std::endl;    
      }
    }
    // Note this test will enumerate special tool properties such as
    //  
    // 00025 # "Alignment", "Number"
    // 00025 # "AlignmentVolume", "Number"
    // 00025 # "AvrRadius", "Number"
    // 00025 # "Name", "Number"
    // 00025 # "CollisionVolume", "Number"
    // 00025 # "Id", "String"
    // 00025 # "Collection", "Number"
    // 00025 # "GoToPar", "Property"
    // etc...
    // However the I++ standard do not specify if this is valid or not
    // also what should be the second string returned for Alignment ?
    // AlignmentVolume ? CollisionVolume ? Id ?
    // 
    // (Etienne) 

  }
  {
    ippEnumAllPropCommandConstPtr cmd = new ippEnumAllPropCommand(25,ippProp(Tool,ScanPar));
    ippResponseList  list;
    GenerateEnumAllPropResponses(cmd,list); 
    if (0) {
      std::cout << " command : " << cmd->getCommandString() << std::endl;
      for (ippResponseList::iterator p = list.begin();p!=list.end();p++)  {
        std::cout << " " << (*p)->getResponseString() << std::endl;    
      }
    }
  }
  {
    ippEnumAllPropCommandConstPtr cmd = new ippEnumAllPropCommand(25,ippProp(Part));
    ippResponseList  list;
    GenerateEnumAllPropResponses(cmd,list); 
    if (0) {
      std::cout << " command : " << cmd->getCommandString() << std::endl;
      for (ippResponseList::iterator p = list.begin();p!=list.end();p++)  {
        std::cout << " " << (*p)->getResponseString() << std::endl;    
      }
    }
    std::string t [] ={ 
      "00025 # \"Temperature\", \"Number\"\r\n",
      "00025 # \"XPanCoefficient\", \"Number\"\r\n",
      "00025 # \"Approach\", \"Property\"\r\n",
      "00025 # \"Approach\", \"Number\"\r\n",
      "00025 # \"Approach.Act\", \"Number\"\r\n",
      "00025 # \"Approach.Def\", \"Number\"\r\n",
      "00025 # \"Approach.Max\", \"Number\"\r\n",
      "00025 # \"Approach.Min\", \"Number\"\r\n",
      "00025 # \"Search\", \"Property\"\r\n",
      "00025 # \"Search\", \"Number\"\r\n",
      "00025 # \"Search.Act\", \"Number\"\r\n",
      "00025 # \"Search.Def\", \"Number\"\r\n",
      "00025 # \"Search.Max\", \"Number\"\r\n",
      "00025 # \"Search.Min\", \"Number\"\r\n",
    };
    {
      size_t nb = sizeof(t)/sizeof(t[0]);
      IPP_UTEST_ASSERT_EQUALS(list.size(),nb);
      for (size_t i=0;i<std::min(nb,list.size());i++)  {
        IPP_UTEST_ASSERT_EQUALS(list[i]->getResponseString(),t[i]);
      }
    }


  }
}
#include "ippdme/Command/ippEnumPropCommand.h"
void ippResponseTestCase::testGenerateEnumPropResponses()
{
  {
    ippEnumPropCommandConstPtr cmd = new ippEnumPropCommand(25,ippProp(FoundTool,PtMeasPar));
    ippResponseList  list;
    GenerateEnumPropResponses(cmd,list);
    if (0) {
      std::cout << " command : " << cmd->getCommandString() << std::endl;
      for (ippResponseList::iterator p = list.begin();p!=list.end();p++)  {
         std::cout << " " << (*p)->getResponseString() << std::endl;    
      }
    }
    IPP_UTEST_ASSERT_EQUALS(list.size(),10U);
    const std::string t1 = "00025 # \"Speed\", \"Property\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(0)->getResponseString(),t1);
    const std::string t2 = "00025 # \"Speed\", \"Number\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(1)->getResponseString(),t2);
    const std::string t3 = "00025 # \"Accel\", \"Property\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(2)->getResponseString(),t3);
    const std::string t4 = "00025 # \"Accel\", \"Number\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(3)->getResponseString(),t4);
    const std::string t5 = "00025 # \"Approach\", \"Property\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(4)->getResponseString(),t5);
    const std::string t6 = "00025 # \"Approach\", \"Number\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(5)->getResponseString(),t6);
    const std::string t7 = "00025 # \"Retract\", \"Property\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(6)->getResponseString(),t7);
    const std::string t8 = "00025 # \"Retract\", \"Number\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(7)->getResponseString(),t8);
    const std::string t9 = "00025 # \"Search\", \"Property\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(8)->getResponseString(),t9);
    const std::string t10 = "00025 # \"Search\", \"Number\"\r\n";
    IPP_UTEST_ASSERT_EQUALS(list.at(9)->getResponseString(),t10);

  }
}

---