mirror of
https://github.com/RetroShare/RetroShare.git
synced 2024-12-13 01:44:29 -05:00
302 lines
9.8 KiB
C++
302 lines
9.8 KiB
C++
/*******************************************************************************
|
|
* unittests/libretroshare/gxs/gen_exchange/genexchangetester.h *
|
|
* *
|
|
* Copyright (C) 2018, Retroshare team <retroshare.team@gmailcom> *
|
|
* *
|
|
* This program is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU Affero General Public License as *
|
|
* published by the Free Software Foundation, either version 3 of the *
|
|
* License, or (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Lesser General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Lesser General Public License *
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
#ifndef GENEXCHANGETESTER_H
|
|
#define GENEXCHANGETESTER_H
|
|
|
|
#include "genexchangetestservice.h"
|
|
#include "gxs/rsgds.h"
|
|
#include "gxs/rsnxs.h"
|
|
|
|
bool operator ==(const RsMsgMetaData& lMeta, const RsMsgMetaData& rMeta);
|
|
bool operator ==(const RsDummyMsg& lMsg, const RsDummyMsg& rMsg);
|
|
bool operator ==(const RsGxsGrpItem& lMsg, const RsGxsGrpItem& rMsg);
|
|
|
|
bool operator ==(const RsGroupMetaData& lMeta, const RsGroupMetaData& rMeta);
|
|
bool operator ==(const RsDummyGrp& lMsg, const RsDummyGrp& rMsg);
|
|
bool operator ==(const RsGxsMsgItem& lMsg, const RsGxsMsgItem& rMsg);
|
|
|
|
/*!
|
|
* The idea of GenExchangeTest is to simplify test
|
|
* of the RsGenExchange via the RsGxsDummyService
|
|
* One can test all publish/request/meta-modify
|
|
* capabilities of RsGenExchange
|
|
* Simplifications comes from: \n
|
|
*
|
|
* - ability to store in and out data for comparison (in data are
|
|
* usually from requests, out data are from publications,
|
|
* but generally what you want to compare) \n
|
|
* - convenience function to poll tokens \n
|
|
* - also allows filling in-data automatically from polls \n
|
|
* - convenience interface for running tests
|
|
*/
|
|
class GenExchangeTest
|
|
{
|
|
public:
|
|
|
|
/*!
|
|
* Constructs the GenExchangeTest with a tokenService
|
|
* @param tokenService This is needed. If not an instance of token service,
|
|
* behaviour of GenExchangeTest is undefined
|
|
*/
|
|
GenExchangeTest(GenExchangeTestService* const mTestService, RsGeneralDataService* dataService, int pollingTO = 5 /* 5 secs default */);
|
|
|
|
virtual ~GenExchangeTest();
|
|
|
|
/*!
|
|
* This should be called in the main
|
|
* routines to execute all tests
|
|
* When implementing ensure units test header
|
|
* is in same file scope as implementation
|
|
* (you chould be using the CHECK functions
|
|
* to assert tests has passed)
|
|
*/
|
|
virtual void runTests() = 0;
|
|
|
|
protected:
|
|
|
|
bool getServiceStatistic(const uint32_t &token, GxsServiceStatistic &servStatistic);
|
|
bool getGroupStatistic(const uint32_t &token, GxsGroupStatistic &grpStatistic);
|
|
|
|
/*!
|
|
* After each request and publish operation this should
|
|
* be called to ensure the operation has completed
|
|
* Requests will result in in data maps being filled
|
|
* @param
|
|
* @param opts
|
|
* @param fill if set to true, the received that is
|
|
* routed to IN data structures
|
|
*/
|
|
void pollForToken(uint32_t token, const RsTokReqOptions& opts, bool fill = false);
|
|
|
|
/*!
|
|
* Allows to poll for token, and receive the message id
|
|
* as acknowledgement. This function blocks for as long the
|
|
* timeout value set on construction of tester
|
|
* @param token
|
|
* @param msgId
|
|
*/
|
|
bool pollForMsgAcknowledgement(uint32_t token, RsGxsGrpMsgIdPair& msgId);
|
|
|
|
/*!
|
|
* Allows to poll for token, and receive the group id
|
|
* as acknowledgement. This function blocks for as long the
|
|
* timeout value set on construction of tester
|
|
* @param token
|
|
* @param msgId
|
|
*/
|
|
bool pollForGrpAcknowledgement(uint32_t token, RsGxsGroupId& msgId);
|
|
|
|
GenExchangeTestService* getTestService();
|
|
RsTokenService* getTokenService();
|
|
// bool testGrpMetaModRequest();
|
|
// bool testMsgMetaModRequest();
|
|
|
|
// convenience functions for clearing IN and OUT data structures
|
|
void clearMsgDataInMap();
|
|
void clearMsgDataOutMap();
|
|
void clearMsgMetaInMap();
|
|
void clearMsgMetaOutMap();
|
|
void clearMsgIdInMap();
|
|
void clearMsgIdOutMap();
|
|
void clearMsgRelatedIdInMap();
|
|
void clearGrpDataInList();
|
|
void clearGrpDataOutList();
|
|
void clearGrpMetaInList();
|
|
void clearGrpMetaOutList();
|
|
void clearGrpIdInList();
|
|
void clearGrpIdOutList();
|
|
|
|
/*!
|
|
* clears up all internal
|
|
* IN and OUT data structure for
|
|
* both msgs and groups
|
|
* frees resources in relation to allocated data
|
|
*/
|
|
void clearAllData();
|
|
|
|
template <class Item>
|
|
void deleteResVector(std::vector<Item*>& v) const
|
|
{
|
|
typename std::vector<Item*>::iterator vit = v.begin();
|
|
for(; vit != v.end(); vit++)
|
|
delete *vit;
|
|
v.clear();
|
|
}
|
|
|
|
// using class to enable partial
|
|
// function specialisation, bit of a hack in a
|
|
// way
|
|
template <class Cont, class Item>
|
|
class Comparison
|
|
{
|
|
public:
|
|
|
|
static bool comparison(const Cont& l, const Cont& r)
|
|
{
|
|
if(l.size() != r.size()) return false;
|
|
|
|
typename Cont::const_iterator vit1 = l.begin(), vit2 = r.begin();
|
|
|
|
while(vit1 != l.end())
|
|
{
|
|
const Item& item1 = (*vit1);
|
|
const Item& item2 = (*vit2);
|
|
if(!(item1 == item2)) return false;
|
|
|
|
vit1++;
|
|
vit2++;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
|
|
template <class Cont, class Item>
|
|
class Comparison<Cont, Item*>
|
|
{
|
|
public:
|
|
|
|
static bool comparison(const Cont& l, const Cont& r)
|
|
{
|
|
if(l.size() != r.size())
|
|
return false;
|
|
|
|
typename Cont::const_iterator vit1 = l.begin(), vit2 = r.begin();
|
|
|
|
while(vit1 != l.end())
|
|
{
|
|
const Item* item1 = (*vit1);
|
|
const Item* item2 = (*vit2);
|
|
if(!(*item1 == *item2))
|
|
return false;
|
|
|
|
vit1++;
|
|
vit2++;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// convenience function for comparing IN and OUT data structures
|
|
bool compareMsgDataMaps() ;
|
|
bool compareMsgIdMaps() ;
|
|
bool compareMsgMetaMaps() ;
|
|
bool compareMsgRelateIdsMap() ;
|
|
bool compareMsgRelatedDataMap() ;
|
|
bool compareGrpData() ;
|
|
bool compareGrpMeta() ;
|
|
bool compareGrpIds() ;
|
|
|
|
void storeToMsgDataOutMaps(const DummyMsgMap& msgDataOut);
|
|
void storeToMsgIdsOutMaps(const GxsMsgIdResult& msgIdsOut);
|
|
void storeToMsgMetaOutMaps(const GxsMsgMetaMap& msgMetaOut);
|
|
|
|
void storeToMsgDataInMaps(const DummyMsgMap& msgDataOut);
|
|
void storeToMsgIdsInMaps(const GxsMsgIdResult& msgIdsOut);
|
|
void storeToMsgMetaInMaps(const GxsMsgMetaMap& msgMetaOut);
|
|
|
|
void storeToGrpIdsOutList(const std::list<RsGxsGroupId>& grpIdOut);
|
|
void storeToGrpMetaOutList(const std::list<RsGroupMetaData>& grpMetaOut);
|
|
void storeToGrpDataOutList(const std::vector<RsDummyGrp*>& grpDataOut);
|
|
|
|
void storeToGrpIdsInList(const std::list<RsGxsGroupId>& grpIdIn);
|
|
void storeToGrpMetaInList(const std::list<RsGroupMetaData>& grpMetaOut);
|
|
void storeToGrpDataInList(const std::vector<RsDummyGrp*>& grpDataOut);
|
|
|
|
/*!
|
|
* This sets up any resources required to operate a test
|
|
*/
|
|
void setUp();
|
|
|
|
/*!
|
|
* Call at end of test to ensure resources
|
|
* used in tests are released
|
|
* This can invalidate other test runs if not called
|
|
*/
|
|
void breakDown();
|
|
|
|
/*!
|
|
* initialises item to random data
|
|
* @param grpItem item to initialise
|
|
*/
|
|
void init(RsDummyGrp& grpItem) const;
|
|
|
|
/*!
|
|
* Initialises meta data to random data
|
|
* @param grpMetaData
|
|
*/
|
|
void init(RsGroupMetaData& grpMetaData) const;
|
|
|
|
/*!
|
|
* Initialises msg item to random data
|
|
* @param msgItem
|
|
*/
|
|
void init(RsDummyMsg& msgItem) const;
|
|
|
|
/*!
|
|
* Initialises meta data to random data
|
|
* @param msgMetaData
|
|
*/
|
|
void init(RsMsgMetaData& msgMetaData) const;
|
|
|
|
|
|
void clearMsgDataMap(DummyMsgMap& msgDataMap) const;
|
|
void clearGrpDataList(std::vector<RsDummyGrp*>& grpData) const;
|
|
|
|
/*!
|
|
* Helper function which sets up groups
|
|
* data in to be used for publication
|
|
* group data
|
|
* @param nGrps number of groups to publish
|
|
* @param groupId the ids for the created groups
|
|
*/
|
|
void createGrps(uint32_t nGrps, std::list<RsGxsGroupId>& groupId);
|
|
|
|
/*!
|
|
* @return random number
|
|
*/
|
|
uint32_t randNum() const;
|
|
|
|
private:
|
|
|
|
std::vector<RsDummyGrp*> mGrpDataOut, mGrpDataIn;
|
|
std::list<RsGroupMetaData> mGrpMetaDataOut, mGrpMetaDataIn;
|
|
std::list<RsGxsGroupId> mGrpIdsOut, mGrpIdsIn;
|
|
|
|
std::map<RsGxsGroupId, std::vector<RsDummyMsg*> > mMsgDataOut, mMsgDataIn;
|
|
GxsMsgMetaMap mMsgMetaDataOut, mMsgMetaDataIn;
|
|
GxsMsgIdResult mMsgIdsOut, mMsgIdsIn;
|
|
|
|
MsgRelatedIdResult mMsgRelatedIdsOut, mMsgRelatedIdsIn;
|
|
GxsMsgRelatedDataMap mMsgRelatedDataMapOut, mMsgRelatedDataMapIn;
|
|
|
|
std::vector<RsGxsGroupId> mRandGrpIds; // ids that exist to help group testing
|
|
|
|
private:
|
|
|
|
RsGeneralDataService* mDataService;
|
|
GenExchangeTestService* mTestService;
|
|
RsTokenService* mTokenService;
|
|
int mPollingTO;
|
|
};
|
|
|
|
#endif // GENEXCHANGETESTER_H
|