ippCommandTestCase.cpp

Go to the documentation of this file.

#include "ippCommandTestCase.h"

#include "ippdme/Parser/ippCommandParser.h"
#include "ippMemoryLeakDetector.h"

void recheck_with_parser(ippCommand& r,bool bParsingShouldFail = false)
{
  ippCommandParser parser;
  std::string t = r.getCommandString();
  parser.setInput(t.c_str());
  
  ippCommandPtr r_check= parser.parseCommand();
  if (bParsingShouldFail) { 
    IPP_UTEST_ASSERT(!r_check);
    return ;
  } 
  if (r_check) {
    std::string t_check = r_check->getCommandString();
    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;
  }
}

#include "ippdme/Command/ippAlignPartCommand.h"
void ippCommandTestCase::testAlignPartCommand()
{
  { 
    ippAlignPartCommand c(25, 
      0,1,2,
      1,2,3,
      45
    );  
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 AlignPart(0., 1., 2., 1., 2., 3., 45.)\r\n");
    recheck_with_parser(c);
  }
  { 
    ippAlignPartCommand c(25, 
      0,1,2,
      1,2,3,
      0,1,2,
      1,2,3,
      45,60
    );  
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 AlignPart(0., 1., 2., 1., 2., 3., 0., 1., 2., 1., 2., 3., 45., 60.)\r\n");
    recheck_with_parser(c);
  }

}
#include "ippdme/Command/ippAlignToolCommand.h"
void ippCommandTestCase::testAlignToolCommand()
{
  { 
    ippAlignToolCommand c(25, 
      0,1,2,
      45
    );  
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 AlignTool(0., 1., 2., 45.)\r\n");
    recheck_with_parser(c);
  }
  { 
    ippAlignToolCommand c(25, 
      0,1,2,
      1,2,3,
      45,70.
    );  
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 AlignTool(0., 1., 2., 1., 2., 3., 45., 70.)\r\n");
    recheck_with_parser(c);
  }
}


#include "ippdme/Command/ippCenterPartCommand.h"
void ippCommandTestCase::testCenterPartCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippCenterPartCommand c(25,1.,2.,3.,4.);
  std::string t = c.getCommandString();
  IPP_UTEST_ASSERT_EQUALS(t,"00025 CenterPart(1., 2., 3., 4.)\r\n");
  recheck_with_parser(c);
 
}
#include "ippdme/Command/ippChangeToolCommand.h"
void ippCommandTestCase::testChangeToolCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippChangeToolCommand c(25,"MyTool");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ChangeTool(\"MyTool\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippEnumAllPropCommand.h"
void ippCommandTestCase::testEnumAllPropCommand()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippEnumAllPropCommand c(25,ippProp(Tool));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumAllProp(Tool())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumAllPropCommand c(25,ippProp(Tool,GoToPar));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumAllProp(Tool.GoToPar())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumAllPropCommand c(25,ippProp(Tool,GoToPar,Speed));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumAllProp(Tool.GoToPar.Speed())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumAllPropCommand c(25,ippProp(Tool,GoToPar,Speed,Min));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumAllProp(Tool.GoToPar.Speed.Min())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumAllPropCommand c(25,ippProp(Part,Temperature));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumAllProp(Part.Temperature())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumAllPropCommand c(25,ippProp(Part));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumAllProp(Part())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumAllPropCommand c(25,ippProp(FoundTool));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumAllProp(FoundTool())\r\n");
    recheck_with_parser(c);
  }
 
}
#include "ippdme/Command/ippEnumPropCommand.h"
void ippCommandTestCase::testEnumPropCommand()
{

  ippMemoryLeakDetector _leakDetector;

  {
    ippEnumPropCommand c(25,ippProp(Tool));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumProp(Tool())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumPropCommand c(25,ippProp(Tool,GoToPar));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumProp(Tool.GoToPar())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumPropCommand c(25,ippProp(Tool,GoToPar,Speed));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumProp(Tool.GoToPar.Speed())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumPropCommand c(25,ippProp(Tool,GoToPar,Speed,Min));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumProp(Tool.GoToPar.Speed.Min())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumPropCommand c(25,ippProp(Part,Temperature));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumProp(Part.Temperature())\r\n");
    recheck_with_parser(c);
  }
  {
    ippEnumPropCommand c(25,ippProp(Part));
    std::string t = c.getCommandString();
    IPP_UTEST_ASSERT_EQUALS(t,"00025 EnumProp(Part())\r\n");
    recheck_with_parser(c);
  }
}

#include "ippdme/Command/ippFindToolCommand.h"
void ippCommandTestCase::testFindToolCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippFindToolCommand c(25,"ThisTool");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 FindTool(\"ThisTool\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}


#include "ippdme/Command/ippGetChangeToolActionCommand.h"
void ippCommandTestCase::testGetChangeToolActionCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippGetChangeToolActionCommand c(25,"ThisTool");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 GetChangeToolAction(\"ThisTool\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}


#include "ippdme/Command/ippGetCommand.h"
void ippCommandTestCase::testGetCommand()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippGetCommand c(25,true,true,true,true,true,true,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 Get(R(), X(), Y(), Z(), Tool.A(), Tool.B(), Tool.C())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetCommand c(25,true,false,false,true,false,true,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 Get(R(), Z(), Tool.B(), Tool.C())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }

}

#include "ippdme/Command/ippGetCsyTransformationCommand.h"
void ippCommandTestCase::testGetCsyTransformationCommand()
{
  ippMemoryLeakDetector _leakDetector;


/*
{
    ippGetCsyTransformationCommand c(25,MachineCsy);
    std::string t = c.getCommandString();
    recheck_with_parser(c);
  }
*/
  {
    ippGetCsyTransformationCommand c(25,MoveableMachineCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetCsyTransformation(MoveableMachineCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetCsyTransformationCommand c(25,MultipleArmCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetCsyTransformation(MultipleArmCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetCsyTransformationCommand c(25,PartCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetCsyTransformation(PartCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetCsyTransformationCommand c(25,JogDisplayCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetCsyTransformation(JogDisplayCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetCsyTransformationCommand c(25,JogMoveCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetCsyTransformation(JogMoveCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetCsyTransformationCommand c(25,SensorCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetCsyTransformation(SensorCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }

}

#include "ippdme/Command/ippGetErrorInfoCommand.h"
void ippCommandTestCase::testGetErrorInfoCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippGetErrorInfoCommand c(25,ArgumentOutOfRange);
  std::string t = c.getCommandString();
  recheck_with_parser(c);

}
#include "ippdme/Command/ippGetPropCommand.h"
void ippCommandTestCase::testGetPropCommand()
{
  ippMemoryLeakDetector _leakDetector;
  {
    ippGetPropCommand c(10);
    c.addProp(ippProp(Tool,PtMeasPar,Approach));
    c.addProp(ippProp(Tool,PtMeasPar,Retract));
    c.addProp(ippProp(Tool,PtMeasPar,Search));
    std::string t = c.getCommandString();
    std::string t_expected = "00010 GetProp(Tool.PtMeasPar.Approach(), Tool.PtMeasPar.Retract(), Tool.PtMeasPar.Search())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(Tool,GoToPar,Accel,Actual));
    c.addProp(ippProp(Tool,Name));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(Tool.GoToPar.Accel.Act(), Tool.Name())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  } 
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(Part,Temperature));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(Part.Temperature())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(Part,XPanCoefficient));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(Part.XPanCoefficient())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  // Part.Approach is mentionned in 6.3.2.13 of ippdme 1.5
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(Part,Approach));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(Part.Approach())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
   // Part.Approach is mentioned in A.2.2 of ippdme 1.5
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(Part,Search));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(Part.Search())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  } 
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(Tool,ScanPar,Speed));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(Tool.ScanPar.Speed())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(Tool,ScanPar,Speed,Max));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(Tool.ScanPar.Speed.Max())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }

}
#include "ippdme/Command/ippGetPropECommand.h"
void ippCommandTestCase::testGetPropECommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippGetPropECommand c(10);
  c.addProp(ippProp(Tool,PtMeasPar,Approach));
  c.addProp(ippProp(Tool,PtMeasPar,Retract));
  c.addProp(ippProp(Tool,PtMeasPar,Search));
  std::string t = c.getCommandString();
  std::string t_expected = "E0010 GetPropE(Tool.PtMeasPar.Approach(), Tool.PtMeasPar.Retract(), Tool.PtMeasPar.Search())\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippGoToCommand.h"
void ippCommandTestCase::testGoToCommand()
{
  ippMemoryLeakDetector _leakDetector;

        /* 
    bool inHasX, bool inHasY, bool inHasZ,
          double  inX, double  inY, double  inZ,
          bool inHasToolA, bool inHasToolB, bool inHasToolC, 
          double  inToolA, double  inToolB, double  inToolC
  */
  {
    ippGoToCommand c(25,
      true,true,true,
      0.5 , 10., 20.,
      true,true,true,
      7.5 , 15., -180.
    );
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GoTo(X(0.5), Y(10.), Z(20.), Tool.A(7.5), Tool.B(15.), Tool.C(-180.))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGoToCommand c(25,
      true,true,true,
      0.5 , 10., 20.,
      false,false,false,
      7.5 , 15., -180.
      );
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GoTo(X(0.5), Y(10.), Z(20.))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGoToCommand c(25,
      false,true,false,
      0.5 , 10., 20.,
      false,false,false,
      7.5 , 15., -180.
      );
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GoTo(Y(10.))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
}

#include "ippdme/Command/ippOnMoveReportECommand.h"
void ippCommandTestCase::testOnMoveReportECommand()
{
  ippMemoryLeakDetector _leakDetector;

/*
  bool inHasR, bool inHasX, bool inHasY, bool inHasZ,
  bool inHasToolA, bool inHasToolB, bool inHasToolC,
        bool inHasDis, bool inHasTime,
        double inTheDis, double inTheTime
*/
  {
    ippOnMoveReportECommand c(25,
      true,false,true,false,
      false,false,false,
      true,true,
      1.0 , 15.
      );
    std::string t = c.getCommandString();
    std::string t_expected = "E0025 OnMoveReportE(Dis(1.), Time(15.), R(), Y())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippOnMoveReportECommand c(25,
      true,true,true,true,
      true,true,true,
      true,true,
      1.0 , 15.
      );
    std::string t = c.getCommandString();
    std::string t_expected = "E0025 OnMoveReportE(Dis(1.), Time(15.), R(), X(), Y(), Z(), Tool.A(), Tool.B(), Tool.C())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
   }
}

#include "ippdme/Command/ippPtMeasCommand.h"
void ippCommandTestCase::testPtMeasCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippPtMeasCommand c(20,
     true,true,true,true,
     1.0,2.0,3.0
     ,4.0,5.0,6.0);
  std::string t = c.getCommandString();
  std::string t_expected = "00020 PtMeas(X(1.), Y(2.), Z(3.), IJK(4., 5., 6.))\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);


}

#include "ippdme/Command/ippOnPtMeasReportCommand.h"
void ippCommandTestCase::testOnPtMeasReportCommand()
{
   /*  
    bool inHasER, bool inHasIJK,bool hasQ
                bool inHasR, bool inHasX, bool inHasY, bool inHasZ,
                bool inHasToolA, bool inHasToolB, bool inHasToolC, bool inHasIJKAct);
*/
  {
    ippOnPtMeasReportCommand c(25,
       true,true,false,
       true,true,true,
       true, true,true,true,false);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 OnPtMeasReport(ER(), IJK(), R(), X(), Y(), Z(), Tool.A(), Tool.B(), Tool.C())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippOnPtMeasReportCommand c(25,
       false,false,false,false,
       false,true,false, 
       false,false,false,false);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 OnPtMeasReport(Y())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippOnPtMeasReportCommand c(25,
       true,true,true,false,
       false,false,false, 
       false,false,false,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 OnPtMeasReport(ER(), IJK(), IJKAct(), Q())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
}


#include "ippdme/Command/ippOnScanReportCommand.h"
void ippCommandTestCase::testOnScanReportCommand()
{
  
  {
    ippMemoryLeakDetector _leakDetector;

    ippOnScanReportCommand c(25);
    c.append(ippOnScanReportCommand::ER);
    c.append(ippOnScanReportCommand::IJK);
    c.append(ippOnScanReportCommand::Q);
    c.append(ippOnScanReportCommand::R);
    c.append(ippOnScanReportCommand::X);
    c.append(ippOnScanReportCommand::Y);
    c.append(ippOnScanReportCommand::Z);
    c.append(ippOnScanReportCommand::ToolA);
    c.append(ippOnScanReportCommand::ToolB);
    c.append(ippOnScanReportCommand::ToolC);

    std::string t = c.getCommandString();
    std::string t_expected = "00025 OnScanReport(ER(), IJK(), Q(), R(), X(), Y(), Z(), Tool.A(), Tool.B(), Tool.C())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippMemoryLeakDetector _leakDetector;

  
    ippOnScanReportCommand c(25);
    
    c.append(ippOnScanReportCommand::ER);
    c.append(ippOnScanReportCommand::IJK);
    c.append(ippOnScanReportCommand::IJKAct);
    c.append(ippOnScanReportCommand::Q);
    c.append(ippOnScanReportCommand::R);
    c.append(ippOnScanReportCommand::X);
    c.append(ippOnScanReportCommand::Y);
    c.append(ippOnScanReportCommand::Z);
    c.append(ippOnScanReportCommand::ToolA);
    c.append(ippOnScanReportCommand::ToolB);
    c.append(ippOnScanReportCommand::ToolC);



    std::string t = c.getCommandString();
    std::string t_expected = "00025 OnScanReport(ER(), IJK(), IJKAct(), Q(), R(), X(), Y(), Z(), Tool.A(), Tool.B(), Tool.C())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
}

#include "ippdme/Command/ippScanInCylEndIsPlaneCommand.h"
void ippCommandTestCase::testScanInCylEndIsPlaneCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanInCylEndIsPlaneCommand c(25,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15,16,17,18,19,20,21.,22,23/* <= is a integer !*/,24,25,26);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanInCylEndIsPlane(1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23, 24., 25., 26.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippScanInCylEndIsSphereCommand.h"
void ippCommandTestCase::testScanInCylEndIsSphereCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanInCylEndIsSphereCommand c(25,
    1.,2.,3.,
    4.,5.,6.,
    7.,8.,9.,
    10.,11.,12.,
    13.,14.,15,
    16,
    17,18,19,20,
    888,
    22,23,24);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanInCylEndIsSphere(1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 888, 22., 23., 24.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippScanInPlaneEndIsCylCommand.h"
void ippCommandTestCase::testScanInPlaneEndIsCylCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanInPlaneEndIsCylCommand c(25,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15,16,17,18,19,20,8888,22,23,24);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanInPlaneEndIsCyl(1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 8888, 22., 23., 24.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);


}

#include "ippdme/Command/ippScanInPlaneEndIsPlaneCommand.h"
void ippCommandTestCase::testScanInPlaneEndIsPlaneCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanInPlaneEndIsPlaneCommand c(25,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15,16,17,18,19,9999,21,22,23);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanInPlaneEndIsPlane(1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 9999, 21., 22., 23.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippScanInPlaneEndIsSphereCommand.h"
void ippCommandTestCase::testScanInPlaneEndIsSphereCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanInPlaneEndIsSphereCommand c(25,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15,16,17,9999,19,20,21);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanInPlaneEndIsSphere(1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 9999, 19., 20., 21.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippScanOnCircleCommand.h"
void ippCommandTestCase::testScanOnCircleCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanOnCircleCommand c(25,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnCircle(1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippScanOnCircleHintCommand.h"
void ippCommandTestCase::testScanOnCircleHintCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanOnCircleHintCommand c(25,1.1,2.2);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnCircleHint(1.1, 2.2)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippScanOnLineCommand.h"
void ippCommandTestCase::testScanOnLineCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanOnLineCommand c(25,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnLine(1., 2., 3., 4., 5., 6., 7., 8., 9., 10.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippScanOnLineHintCommand.h"
void ippCommandTestCase::testScanOnLineHintCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanOnLineHintCommand c(25,1.1,2.2);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnLineHint(1.1, 2.2)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippScanUnknownHintCommand.h"
void ippCommandTestCase::testScanUnknownHintCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippScanUnknownHintCommand c(25,1.1);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanUnknownHint(1.1)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippSetCoordSystemCommand.h"
void ippCommandTestCase::testSetCoordSystemCommand()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippSetCoordSystemCommand c(25,MachineCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 SetCoordSystem(MachineCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippSetCoordSystemCommand c(25,MoveableMachineCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 SetCoordSystem(MoveableMachineCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippSetCoordSystemCommand c(25,MultipleArmCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 SetCoordSystem(MultipleArmCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippSetCoordSystemCommand c(25,PartCsy);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 SetCoordSystem(PartCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  
  {
    ippSetCoordSystemCommand c(25,JogDisplayCsy);// this is illegal in I++
    std::string t = c.getCommandString();
    std::string t_expected = "00025 SetCoordSystem(JogDisplayCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c,true);
  }
  {
    ippSetCoordSystemCommand c(25,JogMoveCsy);// this is illegal in I++
    std::string t = c.getCommandString();
    std::string t_expected = "00025 SetCoordSystem(JogMoveCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c,true);
  }
  {
    ippSetCoordSystemCommand c(25,SensorCsy); // this is illegal in I++
    std::string t = c.getCommandString();
    std::string t_expected = "00025 SetCoordSystem(SensorCsy)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c,true);
  }

}

#include "ippdme/Command/ippSetCsyTransformationCommand.h"
void ippCommandTestCase::testSetCsyTransformationCommand()
{ 
  ippMemoryLeakDetector _leakDetector;

  
  {     
    // note using MachineCsy with ippSetCsyTransformationCommand i
    // is illegal in i++     
    ippSetCsyTransformationCommand c(24,MachineCsy,
      1.,2.,4.0, 10.,15.,30);
    std::string t = c.getCommandString();
    std::string t_expected = "00024 SetCsyTransformation(MachineCsy, 1., 2., 4., 10., 15., 30.)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c,true);
  }
  
  {
    ippSetCsyTransformationCommand c(24,MoveableMachineCsy,
      1.,2.,4.0, 10.,15.,30);
    std::string t = c.getCommandString();
    std::string t_expected = "00024 SetCsyTransformation(MoveableMachineCsy, 1., 2., 4., 10., 15., 30.)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippSetCsyTransformationCommand c(24,MultipleArmCsy,
      1.,2.,4.0, 10.,15.,30);
    std::string t = c.getCommandString();
    std::string t_expected = "00024 SetCsyTransformation(MultipleArmCsy, 1., 2., 4., 10., 15., 30.)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippSetCsyTransformationCommand c(24,PartCsy,
      1.,2.,4.0, 10.,15.,30);
    std::string t = c.getCommandString();
    std::string t_expected = "00024 SetCsyTransformation(PartCsy, 1., 2., 4., 10., 15., 30.)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippSetCsyTransformationCommand c(24,JogDisplayCsy,
      1.,2.,4.0, 10.,15.,30);
    std::string t = c.getCommandString();
    std::string t_expected = "00024 SetCsyTransformation(JogDisplayCsy, 1., 2., 4., 10., 15., 30.)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippSetCsyTransformationCommand c(24,JogMoveCsy,
      1.,2.,4.0, 10.,15.,30);
    std::string t = c.getCommandString();
    std::string t_expected = "00024 SetCsyTransformation(JogMoveCsy, 1., 2., 4., 10., 15., 30.)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippSetCsyTransformationCommand c(24,SensorCsy,
      1.,2.,4.0, 10.,15.,30);
    std::string t = c.getCommandString();
    std::string t_expected = "00024 SetCsyTransformation(SensorCsy, 1., 2., 4., 10., 15., 30.)\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
}

#include "ippdme/Command/ippSetPropCommand.h"
void ippCommandTestCase::testSetPropCommand()
{
  ippMemoryLeakDetector _leakDetector;
  
  ippSetPropCommand c(10);
  c.addPropValue(ippProp(Tool,PtMeasPar,Approach),10);
  c.addPropValue(ippProp(Tool,PtMeasPar,Retract),20);
  c.addPropValue(ippProp(Tool,PtMeasPar,Search),30);
  std::string t = c.getCommandString();
  std::string t_expected = "00010 SetProp(Tool.PtMeasPar.Approach(10.), Tool.PtMeasPar.Retract(20.), Tool.PtMeasPar.Search(30.))\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippSetToolCommand.h"
void ippCommandTestCase::testSetToolCommand()
{
  ippMemoryLeakDetector _leakDetector;
  ippSetToolCommand c(25,"SomeTool");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 SetTool(\"SomeTool\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippStopDaemonCommand.h"
void ippCommandTestCase::testStopDaemonCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippStopDaemonCommand c(25,23);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 StopDaemon(E0023)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippTiltCenterPartCommand.h"
void ippCommandTestCase::testTiltCenterPartCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippTiltCenterPartCommand c(25,
    1.,2.,3,
    10.,11,12,
    13.);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 TiltCenterPart(1., 2., 3., 10., 11., 12., 13.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
 
  recheck_with_parser(c);
}

#include "ippdme/Command/ippTiltPartCommand.h"
void ippCommandTestCase::testTiltPartCommand()
{
  ippMemoryLeakDetector _leakDetector;

  ippTiltPartCommand c(25,
    1.,2.,3,
    13.);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 TiltPart(1., 2., 3., 13.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippLockAxisCommand.h"
void ippCommandTestCase::testLockAxisCommand()
{
  ippMemoryLeakDetector _leakDetector;

  {
    ippLockAxisCommand c(25,true,true,true,true,true,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 LockAxis(C(), Phi(), R(), X(), Y(), Z())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippLockAxisCommand c(25,false,true,true,true,true,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 LockAxis(Phi(), R(), X(), Y(), Z())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippLockAxisCommand c(25,false,false,true,true,true,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 LockAxis(R(), X(), Y(), Z())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippLockAxisCommand c(25,false,false,false,true,true,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 LockAxis(X(), Y(), Z())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippLockAxisCommand c(25,false,false,false,true,false,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 LockAxis(X(), Z())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
}

//xx #include "ippdme/Command/ippReQualifyCommand.h"
void ippCommandTestCase::testReQualifyCommand()
{
  ippCommand  c(25,ReQualify);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ReQualify()\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);

}

#include "ippdme/Command/ippEnumToolsCommand.h"
void ippCommandTestCase::testEnumToolsCommand()
{
  ippEnumToolsCommand  c(25);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 EnumTools()\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}


#include "ippdme/Command/ippEnumToolCollectionCommand.h"
void ippCommandTestCase::testEnumToolCollectionCommand()
{
  ippEnumToolCollectionCommand  c(25,"SomeCollection");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 EnumToolCollection(\"SomeCollection\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippEnumAllToolCollectionsCommand.h"
void ippCommandTestCase::testEnumAllToolCollectionsCommand()
{
  ippEnumAllToolCollectionsCommand  c(25,"Stuff");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 EnumAllToolCollections(\"Stuff\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippOpenToolCollectionCommand.h"
void ippCommandTestCase::testOpenToolCollectionCommand()
{
  ippOpenToolCollectionCommand  c(25,"Stuff");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 OpenToolCollection(\"Stuff\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippPtMeasSelfCenterCommand.h"
void ippCommandTestCase::testPtMeasSelfCenterCommand()
{
  ippPtMeasSelfCenterCommand  c(25,1,2,3,ippTargetVector(4,5,6));
  std::string t = c.getCommandString();
  std::string t_expected = "00025 PtMeasSelfCenter(X(1.), Y(2.), Z(3.), IJK(4., 5., 6.))\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippPtMeasSelfCenterLockedCommand.h"
void ippCommandTestCase::testPtMeasSelfCenterLockedCommand()
{
  {
    ippPtMeasSelfCenterLockedCommand  c(25,1,2,3,ippTargetVector(4,5,6),ippTargetVector(7,8,9));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 PtMeasSelfCenterLocked(X(1.), Y(2.), Z(3.), IJK(4., 5., 6.), LMN(7., 8., 9.))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
}

#include "ippdme/Command/ippGetNamedCsyTransformationCommand.h"
void ippCommandTestCase::testGetNamedCsyTransformationCommand()
{
  ippGetNamedCsyTransformationCommand  c(25,"Stuff");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 GetNamedCsyTransformation(\"Stuff\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippSaveNamedCsyTransformationCommand.h"
void ippCommandTestCase::testSaveNamedCsyTransformationCommand()
{
  ippSaveNamedCsyTransformationCommand  c(25,"Stuff",1,2,3,4,5,6);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 SaveNamedCsyTransformation(\"Stuff\", 1., 2., 3., 4., 5., 6.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}


#include "ippdme/Command/ippSaveActiveCoordSystemCommand.h"
void ippCommandTestCase::testSaveActiveCoordSystemCommand()
{
  ippSaveActiveCoordSystemCommand  c(25,"Stuff");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 SaveActiveCoordSystem(\"Stuff\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}
#include "ippdme/Command/ippLoadCoordSystemCommand.h"
void ippCommandTestCase::testLoadCoordSystemCommand() 
{
  ippLoadCoordSystemCommand  c(25,"Stuff");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 LoadCoordSystem(\"Stuff\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}
#include "ippdme/Command/ippDeleteCoordSystemCommand.h"
void ippCommandTestCase::testDeleteCoordSystemCommand() 
{
  ippDeleteCoordSystemCommand  c(25,"Stuff");
  std::string t = c.getCommandString();
  std::string t_expected = "00025 DeleteCoordSystem(\"Stuff\")\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}
#include "ippdme/Command/ippEnumCoordSystemsCommand.h"
void ippCommandTestCase::testEnumCoordSystemsCommand() 
{
  ippEnumCoordSystemsCommand  c(25);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 EnumCoordSystems()\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c);
}

#include "ippdme/Command/ippScanUnknownDensityCommand.h"
void ippCommandTestCase::testScanUnknownDensityCommand() 
{
  {
    ippScanUnknownDensityCommand  c(25,1.,true,10.);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 ScanUnknownDensity(Dis(1.), Angle(10.))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c); 
  }
  {
    ippScanUnknownDensityCommand  c(25,2.,false,10.);
    std::string t = c.getCommandString();
    // the standard ( v.1.5 in 13.1.1 ) specifies that Dis without angle is possible 
    std::string t_expected = "00025 ScanUnknownDensity(Dis(2.))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c); 
  }
  // 
  // [to do] shall we test that Angle without Dis is NOT possible ?

}
#include "ippdme/Command/ippScanOnCurveDensityCommand.h"
void ippCommandTestCase::testScanOnCurveDensityCommand() 
{
  {
    ippScanOnCurveDensityCommand  c(25,1.,true,10.,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 ScanOnCurveDensity(Dis(1.), Angle(10.), AtNominals(1))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c); 
  }
  //the standard says:
  // If 1 the arguments Dis and Angle are ignored
  // Dis() or/and AtNominals() without Angle also possible.
  {
    ippScanOnCurveDensityCommand  c(25,2.,false,10.,true);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 ScanOnCurveDensity(Dis(2.), AtNominals(1))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c); 
  }
  {
    // please ask the commitee if this combination is valid !
    ippScanOnCurveDensityCommand  c(25,3.,false,10.,false);
    std::string t = c.getCommandString();
    std::string t_expected = "00025 ScanOnCurveDensity(Dis(3.), AtNominals(0))\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c); 
  }
}


#include "ippdme/Command/ippScanOnCurveHintCommand.h"
void ippCommandTestCase::testScanOnCurveHintCommand()
{
  // Deviation,MinRadiusOfCurvature
  ippScanOnCurveHintCommand  c(25,0.1,0.2);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnCurveHint(0.1, 0.2)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c); 
}

#include "ippdme/Command/ippScanOnCurveCommand.h"
void ippCommandTestCase::testScanOnCurveCommand_Type1()
{

  ippScanOnCurveCommand  c(25,true,ippScanOnCurveCommand::Type1);
  c.addPoint(1.,2.,3.,4.,5.,6.,1000);
  c.addPoint(11.,12.,13.,14.,15.,16.,1001);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnCurve(Closed(1), "
                           "Format(X(),Y(),Z(),IJK(),tag), "
                           "Data(1., 2., 3., 4., 5., 6., 1000, 11., 12., 13., 14., 15., 16., 1001))\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c); 
}
void ippCommandTestCase::testScanOnCurveCommand_Type2()
{

  ippScanOnCurveCommand  c(25,true,ippScanOnCurveCommand::Type2);
  c.addPoint(1.,2.,3.,4.,5.,6.,1000,1.,2.,3.);
  c.addPoint(11.,12.,13.,14.,15.,16.,1001,1.,2.,3.);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnCurve(Closed(1), "
                           "Format(X(),Y(),Z(),IJK(),tag,pi,pj,pk),"
                           " Data(1., 2., 3., 4., 5., 6., 1000, 1., 2., 3.,"
                                " 11., 12., 13., 14., 15., 16., 1001, 1., 2., 3.))\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c); 
}
void ippCommandTestCase::testScanOnCurveCommand_Type3()
{

  ippScanOnCurveCommand  c(25,true,ippScanOnCurveCommand::Type3);
  c.addPoint(1.,2.,3.,4.,5.,6.,1000, 1., 2., 3., 4., 5., 6.);
  c.addPoint(11.,12.,13.,14.,15.,16.,1001, 1., 2., 3., 4., 5., 6.);
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnCurve(Closed(1), "
                           "Format(X(),Y(),Z(),IJK(),tag,pi,pj,pk,si,sj,sk), "
                           "Data(1., 2., 3., 4., 5., 6., 1000,"
                           " 1., 2., 3., 4., 5., 6.,"
                           " 11., 12., 13., 14., 15., 16., 1001,"
                           " 1., 2., 3., 4., 5., 6.))\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c); 
}
#include "ippdme/Command/ippScanOnHelixCommand.h"
void ippCommandTestCase::testScanOnHelixCommand()
{
  ippScanOnHelixCommand  c(25,
    1.,2.,3.,
    4.,5.,6.,
    7.,8.,9.,
    10.,11.,12.,13.
    );
  std::string t = c.getCommandString();
  std::string t_expected = "00025 ScanOnHelix(1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13.)\r\n";
  IPP_UTEST_ASSERT_EQUALS(t,t_expected);
  recheck_with_parser(c); 
}

#include "ippdme/Command/ippGetPropCommand.h"
void ippCommandTestCase::testFoundToolProperties()
{
  // 6.3.12-15
  //new in 1.5 verifies that Tool Properties CollisionVolume, Alignment, 
  //            AvrRadius, AlignmentVolume also for FoundTool
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(FoundTool,CollisionVolume));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(FoundTool.CollisionVolume())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(FoundTool,Alignment));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(FoundTool.Alignment())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(FoundTool,AvrRadius));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(FoundTool.AvrRadius())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
  {
    ippGetPropCommand c(25);
    c.addProp(ippProp(FoundTool,AlignmentVolume));
    std::string t = c.getCommandString();
    std::string t_expected = "00025 GetProp(FoundTool.AlignmentVolume())\r\n";
    IPP_UTEST_ASSERT_EQUALS(t,t_expected);
    recheck_with_parser(c);
  }
}

---