PMockBackend.cpp

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/

#include <sstream>

#include "data_stream_check_value.h"
#include "PMockBackend.h"

///Check given value compare to the reference size
/**	@param testName : name of the current test
 * 	@param vecData : vector of data to be checked
 * 	@param vecReferenceData : vector of reference data
 * 	@return true on success, false otherwise
*/
template<>
bool checkValue<DataStreamType>(const std::string & testName, const std::vector<DataStreamType> & vecData, const std::vector<DataStreamType> & vecReferenceData){
	if(vecData.size() != vecReferenceData.size()){
		std::cout << "checkValue<DataStreamType> : "<<testName<<" => vecData.size(" << vecData.size() << ") !=  vecReferenceData.size("<<vecReferenceData.size()<<")" << std::endl;
		return false;
	}
	bool b(true);
	for(size_t i(0lu); i < vecData.size() && b; ++i){
		b &= vecData[i] == vecReferenceData[i];
		if(!b){
			std::cout << "checkValue<DataStreamType> : "<<testName<<" => vecData["<<i<<"](" << (int)vecData[i] << ") !=  vecReferenceData["<<i<<"]("<<(int)vecReferenceData[i]<<")" << std::endl;
		}
	}
// 	if(b){std::cout << "checkValue : "<<testName<<" => Ok"<<std::endl;}
// 	else{std::cout << "checkValue : "<<testName<<" => WRONG!!!!"<<std::endl;}
	return b;
}

///Default constructor of PMockBackend
PMockBackend::PMockBackend(){
	
}

///Create param for a client socket
/**	@param address : address of the server to be connected to
 * 	@param port : port to be used
 * 	@param isMockRecord : true if the mock is in record mode
 * 	@param mockDirectory : directory where to find/save mocks
 * 	@return corresponding parameters
*/
PMockBackend::Param PMockBackend::client(const std::string & address, size_t port, bool isMockRecord, const std::string & mockDirectory){
	PMockBackend::Param param;
	param.address = address;
	param.port = port;
	param.isMockRecord = isMockRecord;
	param.mockDirectory = mockDirectory;
	return param;
}

///Create param for a server socket
/**	@param address : address of the server to be connected to
 * 	@param port : port to be used
 * 	@param isMockRecord : true if the mock is in record mode
 * 	@param mockDirectory : directory where to find/save mocks
 * 	@return corresponding parameters
*/
PMockBackend::Param PMockBackend::server(const std::string & address, size_t port, bool isMockRecord, const std::string & mockDirectory){
	return PMockBackend::client(address, port, isMockRecord, mockDirectory);
}

///Create a client socket
/**	@param[out] socket : socket to be created
 * 	@param param : extra customisable parameters for the creation of the socket (depends on the backend)
 * 	@return true if the socket has been created, false otherwise
*/
bool PMockBackend::createClientSocket(PMockBackend::Socket & socket, const PMockParam & param){
	socket.param = param;
	socket.eventIndex = 0lu;
	std::stringstream socketFileName;
	if(param.mockDirectory != ""){
		socketFileName << param.mockDirectory << "/";
	}
	socketFileName << param.address << "_" << param.port << ".pmockbackend";
	socket.fileNameMessage = socketFileName.str();
	bool b(true);
	if(!socket.param.isMockRecord){	//If we are not in record mode, we load all the exchange
		b &= data_load(socket.fileNameMessage, socket.vecMessage);
		if(!b){
			std::cerr << "PMockBackend::createClientSocket : cannot load file '"<<socket.fileNameMessage<<"'" << std::endl;
		}
	}
	return b;
}

///Create a client socket
/**	@param[out] socket : socket to be created
 * 	@param param : extra customisable parameters for the creation of the socket (depends on the backend)
 * 	@return true if the socket has been created, false otherwise
*/
bool PMockBackend::createServerSocket(PMockBackend::Socket & socket, const PMockParam & param){
	return createClientSocket(socket, param);
}

///Send message on the given socket
/**	@param socket : socket to be used
 * 	@param msg : message to be sent
 * 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
 * 	@return true on success, false otherwise
*/
bool PMockBackend::send(PMockBackend::Socket & socket, const PMockBackend::Message & msg, PSendFlag::PSendFlag flag){
	bool b(true);
	if(socket.param.isMockRecord){	//If we record all events
		socket.vecMessage.push_back(msg);
	}else{
		if(socket.vecMessage.size() == 0lu){
			std::cerr << "PMockBackend::send : empty vector of message" << std::endl;
			return false;
		}
		//Let's pick the current message
		if(socket.eventIndex >= socket.vecMessage.size()){
			socket.eventIndex = 0lu;	//Let's loop if all the events were used
		}
		//Let's check if the current message matches the message we are supposed to send
		std::stringstream strEvent;
		strEvent << socket.eventIndex;
		b &= checkValue("PMockBackend::send : event " + strEvent.str(), msg, socket.vecMessage[socket.eventIndex]);
	}
	++socket.eventIndex;
	return b;
}

///Recieve message from the given socket
/**	@param socket : socket to be used
 * 	@param msg : message to be recieved
 * 	@param flag : flag to be used to send the message (BLOCK, NON_BLOCK, etc)
 * 	@return true on success, false otherwise
*/
bool PMockBackend::recv(PMockBackend::Socket & socket, PMockBackend::Message & msg, PRecvFlag::PRecvFlag flag){
	if(socket.param.isMockRecord){	//If we record all events
		socket.vecMessage.push_back(msg);
	}else{
		if(socket.vecMessage.size() == 0lu){
			std::cerr << "PMockBackend::recv : empty vector of message" << std::endl;
			return false;
		}
		//Let's pick the current message
		if(socket.eventIndex >= socket.vecMessage.size()){
			socket.eventIndex = 0lu;	//Let's loop if all the events were used
		}
		msg = socket.vecMessage[socket.eventIndex];
	}
	++socket.eventIndex;
	return true;
}

///Resize a message
/**	@param[out] msg : message to be resized
 * 	@param sizeMsg : new size of the message
*/
void PMockBackend::msgResize(PMockBackend::Message & msg, size_t sizeMsg){
	msg.resize(sizeMsg);
}

///Get the size of a message
/**	@param msg : message to be used
 * 	@return size of the message in bytes
*/
size_t PMockBackend::msgSize(const PMockBackend::Message & msg){
	return msg.size();
}

///Get the data of a message
/**	@param msg : message to be used
 * 	@return data of the message in bytes
*/
const DataStreamIter PMockBackend::msgData(const PMockBackend::Message & msg){
	return (const DataStreamIter)msg.data();
}

///Get the data of a message
/**	@param msg : message to be used
 * 	@return data of the message in bytes
*/
DataStreamIter PMockBackend::msgData(PMockBackend::Message & msg){
	return msg.data();
}

///Close the given socket
/**	@param[out] socket : socket to be closed
*/
void PMockBackend::close(PMockBackend::Socket & socket){
	if(socket.param.isMockRecord){
		data_save(socket.fileNameMessage, socket.vecMessage);
	}
}

///Say if the given socket is connected
/**	@param socket : socket to be checked
 * 	@return true if the socket is connected, false otherwise
*/
bool PMockBackend::isConnected(const PMockBackend::Socket & socket){
	return true;
}