ippSimpleServerTestCase.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 "ippdme/winsock.h"
#include "ippSimpleServerTestCase.h"
#include "ippMemoryLeakDetector.h"

#include "ippdme/Server/ippSimpleServer.h"
#include "ippdme/Server/ippSimpleClient.h"
#include "ippdme/Server/ippLogger.h"
#include "ippdme/assert.h"

int PortForTesting = 12940;





CXXTEST_ENUM_TRAITS( ippSimpleServer::STATE,
                     CXXTEST_ENUM_MEMBER( ippSimpleServer::uninitialized )
                     CXXTEST_ENUM_MEMBER( ippSimpleServer::listening )
                     CXXTEST_ENUM_MEMBER( ippSimpleServer::connected ));



CXXTEST_ENUM_TRAITS( ippSimpleClient::STATE,
                     CXXTEST_ENUM_MEMBER( ippSimpleClient::disconnected )
                     CXXTEST_ENUM_MEMBER( ippSimpleClient::trying_to_connect )
                     CXXTEST_ENUM_MEMBER( ippSimpleClient::connected ));

class ippTraceLogger : public ippLogger
{
private:
  std::string _prefix;
public:
  bool _ouput_on_cout;

  ippTraceLogger(const char* prefix)
  :_prefix(prefix),_ouput_on_cout(false)
  {
  
  }
  virtual void WriteLine(const char* str)
  {
    if(_ouput_on_cout) { 
      std::cout << _prefix << " " << str <<std::endl;
    }
  }


};
class ippCommand;
//-----------------------------------------------------------------------------

void ippSimpleServerTestCase::testSimpleServer1()
{
  //PortForTesting++;
  // try 3 connections/disconnection
  ippSimpleServer server;  
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::uninitialized );
  
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));  
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::listening );
  server.PowerOff();
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::uninitialized );

  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::listening );

  server.PowerOff();
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::uninitialized );

  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::listening );
  server.PowerOff();
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::uninitialized );

  // --- now  try to have a client connecting
  //     several type
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::listening );

  ippSimpleClient client;

  for (int i=0 ;i < 10 ; i++) 
  {
     
    std::cout << " testSimpleServer1 iteration " << i << std::endl;
    client.Connect("localhost",PortForTesting);
    client.HeartBeat();server.HeartBeat(); 
    client.HeartBeat();server.HeartBeat();
    client.HeartBeat();server.HeartBeat();
    IPP_UTEST_ASSERT_EQUALS(server.GetState(),ippSimpleServer::connected );
    IPP_UTEST_ASSERT_EQUALS(client.GetState(),ippSimpleClient::connected );
    IPP_UTEST_ASSERT(client.ReadyToSend() );

    client.Disconnect();
    server.ProbeConnection();
    client.HeartBeat();server.HeartBeat();
    client.HeartBeat();server.HeartBeat();
    client.HeartBeat();server.HeartBeat();
    IPP_UTEST_ASSERT_EQUALS(server.GetState(),ippSimpleServer::listening );
    IPP_UTEST_ASSERT_EQUALS(client.GetState(),ippSimpleClient::disconnected );
    IPP_UTEST_ASSERT(!client.ReadyToSend() );
    ippSleep(20);
  }
    
  server.PowerOff();
}


void ippSimpleServerTestCase::testSimpleServer2()
{

  //PortForTesting++;
  ippTraceLogger clientLogger("client");
  ippTraceLogger serverLogger("server");
  clientLogger._ouput_on_cout = true;
  serverLogger._ouput_on_cout = true;

  ippSimpleServer server;
  server.setLogger(&serverLogger);
  
  // start the server
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));

  ippSimpleClient client;


  client.setLogger(&clientLogger);
  client.Connect("localhost",PortForTesting);



  server.HeartBeat();client.HeartBeat();
  server.HeartBeat();client.HeartBeat();

  
  // send a valid command 
  client.SendCommand("00001 StartSession()");
  server.HeartBeat();client.HeartBeat();
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(!client.NeedToSendClearAllErrors());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  // send a command with a \r or \n in the middle of the string
  client.SendCommand("00001 Start\rSe\nssion()");
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(client.NeedToSendClearAllErrors());
  client.ClearAllErrors(); server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(!client.NeedToSendClearAllErrors());
  IPP_UTEST_ASSERT(client.ReadyToSend());
 
  // send a command with a invalid character the middle of the string
  client.SendCommand("00001 LoadTool(\"\t\")");
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(client.NeedToSendClearAllErrors());
  client.ClearAllErrors(); server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(!client.NeedToSendClearAllErrors());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  // send a command with a bag tag
  client.SendCommand("0000%1 StartSession()");
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(client.ReadyToSend());
  IPP_UTEST_ASSERT(client.NeedToSendClearAllErrors());
  client.ClearAllErrors(); server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(!client.NeedToSendClearAllErrors());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  // send a command with no space at position 6
  client.SendCommand("00001StartSession()");
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(client.ReadyToSend());
  IPP_UTEST_ASSERT(client.NeedToSendClearAllErrors());
  client.ClearAllErrors(); server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(!client.NeedToSendClearAllErrors());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  int n=100;
  while(n--) {
     server.HeartBeat();
     client.HeartBeat();
  }
  
}

void ippSimpleServerTestCase::testSimpleServer3()
{

  //PortForTesting++;
  // test what is going on with the client
  //  when server disconnect unexepectidally
  
  ippTraceLogger clientLogger("client");
  ippTraceLogger serverLogger("server");
  clientLogger._ouput_on_cout = true;
  serverLogger._ouput_on_cout = true;

  ippSimpleServer server;
  server.setLogger(&serverLogger);
  
  // start the server
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));

  ippSimpleClient client;
  client.setLogger(&clientLogger);

  client.Connect("localhost",PortForTesting);
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client.GetState(), ippSimpleClient::connected );

  server.HeartBeat();client.HeartBeat();

  
  // send a valid command 
  client.SendCommand("00001 StartSession()");
  server.HeartBeat();  client.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client.GetState() , ippSimpleClient::connected );

  server.PowerOff();
  client.SendCommand("0001 StartSession()");
  client.HeartBeat();
  client.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client.GetState() , ippSimpleClient::disconnected );

}
void ippSimpleServerTestCase::testSimpleServer4()
{
  //PortForTesting++;
  // check that only client can connect to a 
  // server at a particular time.

  ippTraceLogger clientLogger("client");
  ippTraceLogger serverLogger("server");

  ippSimpleServer server;
  server.setLogger(&serverLogger);
  
  // start the server
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));

  ippSimpleClient client1;
  client1.setLogger(&clientLogger);
  client1.Connect("localhost",PortForTesting);
  server.HeartBeat();client1.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client1.GetState() , ippSimpleClient::connected );

  ippSimpleClient client2;
  client2.setLogger(&clientLogger);
  client2.Connect("localhost",PortForTesting);
  server.HeartBeat();client2.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client2.GetState() , ippSimpleClient::disconnected );

  ippSimpleClient client3;
  client3.setLogger(&clientLogger);
  client3.Connect("localhost",PortForTesting);
  server.HeartBeat();client3.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client3.GetState() , ippSimpleClient::disconnected );
 
}
#include "ippTestFolder.h"
#include "ippdme/Parser/ippCommandParser.h"
#include <fstream>
void ippSimpleServerTestCase::SendCommands(
 ippSimpleClient& client,
 ippSimpleServer& server,
 const char* filename
)
{

  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 {


      ippCommandParser cmdParser;

      cmdParser.setInput(str.c_str());
      ippCommandPtr command = cmdParser.parseCommand();
      
      IPP_UTEST_ASSERT(command);
      if (command ) {
        client.SendCommand(command);

        while( (client.GetState() == ippSimpleClient::connected) && !client.ReadyToSend()) {
          client.HeartBeat();server.HeartBeat();
        }
      }

    }
  }
}


#include "ippTestFolder.h"

void ippSimpleServerTestCase::testSimpleServer5()
{
  //PortForTesting++;
  // this test applies the "AllCmdOK commands to 
  // a server, through a simple client.
 
  ippTraceLogger clientLogger("client");
  ippTraceLogger serverLogger("server");

  ippSimpleServer server;
  server.setLogger(&serverLogger);
  
  // start the server
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));

  ippSimpleClient client;
  client.setLogger(&clientLogger);

  client.Connect("localhost",PortForTesting);
  server.HeartBeat();client.HeartBeat();

  IPP_UTEST_ASSERT(client.GetState() == ippSimpleClient::connected );

  server.HeartBeat();client.HeartBeat();

  
  ippTestFolder folder;
  bool bSuccess = folder.find_first_file(test_file_folder().c_str(),"AllCmdOK.prg");
  IPP_UTEST_ASSERT(bSuccess);

  while(bSuccess) {
    
    std::string filename = folder.current_filename();
    SendCommands(client,server,filename.c_str());
    bSuccess = folder.next();

  }
}


void ippSimpleServerTestCase::testSimpleServerStartSessionEndSession()
{
   //PortForTesting++;
  ippTraceLogger clientLogger("client");
  ippTraceLogger serverLogger("server");
  

  clientLogger._ouput_on_cout = true;
  serverLogger._ouput_on_cout = true;

  ippSimpleServer server;
  server.setLogger(&serverLogger);
  // start the server
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));
  IPP_UTEST_ASSERT(!server.InSession());

  ippSimpleClient client;

  client.setLogger(&clientLogger);
  client.Connect("localhost",PortForTesting);
  server.HeartBeat();client.HeartBeat();
  server.HeartBeat();client.HeartBeat();
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client.GetState() , ippSimpleClient::connected );
  IPP_UTEST_ASSERT(!server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  
  // verify that calling EndSession doesn't arm
  client.SendCommand(new ippCommand(1,CommandTag,EndSession));
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(!server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  // now try a StartSession/EndSession sequence
  client.SendCommand(new ippCommand(1,CommandTag,StartSession));
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());
  IPP_UTEST_ASSERT(client.ReadyToSend());
  
  client.SendCommand(new ippCommand(1,CommandTag,EndSession));
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(!server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  // now try a StartSession/StartSession 
  client.SendCommand(new ippCommand(1,CommandTag,StartSession));
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  client.SendCommand(new ippCommand(1,CommandTag,StartSession));
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(server.InSession());
  IPP_UTEST_ASSERT(client.InErrorState());
  client.ClearAllErrors();
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());
  IPP_UTEST_ASSERT(client.ReadyToSend());

  


}



void ippSimpleServerTestCase::testSimpleServerReceivingInvalidCommand()
{
  ippTraceLogger clientLogger("client");
  ippTraceLogger serverLogger("server");

  clientLogger._ouput_on_cout = true;
  serverLogger._ouput_on_cout = true;

  ippSimpleServer server;
  server.setLogger(&serverLogger);
  // start the server
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));
  IPP_UTEST_ASSERT(!server.InSession());

  ippSimpleClient client;

  client.setLogger(&clientLogger);
  
  client.Connect("localhost",PortForTesting);
  server.HeartBeat();client.HeartBeat();
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client.GetState() , ippSimpleClient::connected );
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::connected );
  IPP_UTEST_ASSERT(!server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());

  // now try a StartSession/EndSession sequence
  client.SendCommand(new ippCommand(1,CommandTag,StartSession));
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());

  // now send an invalid command
  IPP_UTEST_ASSERT(client.ReadyToSend());
  client.SendCommand("00001 ChangeTool(\"SomeTool\",badparameter)");
  server.HeartBeat();client.HeartBeat();
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(server.InSession());
  IPP_UTEST_ASSERT(client.InErrorState());
  IPP_UTEST_ASSERT(client.ReadyToSend());


}

#include "ippMockExecutor.h"



void ippSimpleServerTestCase::testSimpleServerReceivingAbortE()
{
  ippTraceLogger clientLogger("client");
  ippTraceLogger serverLogger("server");

  clientLogger._ouput_on_cout = true;
  serverLogger._ouput_on_cout = true;

  ippMockExecutor fake_exectutor;
  ippSimpleServer server(&fake_exectutor);
  server.setLogger(&serverLogger);



  // start the server
  IPP_UTEST_ASSERT(server.PowerOn(PortForTesting));
  IPP_UTEST_ASSERT(!server.InSession());

  ippSimpleClient client;

  client.setLogger(&clientLogger);
  
  client.Connect("localhost",PortForTesting);
  server.HeartBeat();client.HeartBeat();
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT_EQUALS(client.GetState() , ippSimpleClient::connected );
  IPP_UTEST_ASSERT_EQUALS(server.GetState() , ippSimpleServer::connected );
  IPP_UTEST_ASSERT(!server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());

  // now try a StartSession/EndSession sequence
  client.SendCommand(new ippCommand(1,CommandTag,StartSession));
  server.HeartBeat();client.HeartBeat();
  IPP_UTEST_ASSERT(server.InSession());
  IPP_UTEST_ASSERT(!client.InErrorState());

  // now send an invalid command
  client.SendCommand(new ippScanOnLineCommand(10  , 1.,1.,1.,10.,10.,10.,0.,0.,1.0,1.));
  server.HeartBeat();client.HeartBeat();
  client.SendCommand(new ippScanOnLineCommand(11  , 1.,1.,1.,10.,10.,10.,0.,0.,1.0,1.));
  server.HeartBeat();client.HeartBeat();
  client.SendCommand(new ippScanOnLineCommand(12  , 1.,1.,1.,10.,10.,10.,0.,0.,1.0,1.));
  server.HeartBeat();client.HeartBeat();
  client.SendCommand(new ippCommand(14,AbortE));
  server.HeartBeat();client.HeartBeat();
  client.SendCommand(new ippScanOnLineCommand(16  , 1.,1.,1.,10.,10.,10.,0.,0.,1.0,1.));
  server.HeartBeat();client.HeartBeat();

  int watch_dog =1000;
  while(watch_dog-->0 && client.NumberOfUncompletedCommandsInQueue() > 0) {
    server.HeartBeat();client.HeartBeat();
  }
}

---