diff --git a/tests/librssimulator/librssimulator.pro b/tests/librssimulator/librssimulator.pro index af84b5843..14f1d5c6e 100644 --- a/tests/librssimulator/librssimulator.pro +++ b/tests/librssimulator/librssimulator.pro @@ -40,8 +40,13 @@ SOURCES += peer/PeerNode.cc \ ###################### Unit Tests ############################### HEADERS += testing/IsolatedServiceTester.h \ + testing/SetServiceTester.h \ + testing/SetPacket.h \ + testing/SetFilter.h \ SOURCES += testing/IsolatedServiceTester.cc \ + testing/SetServiceTester.cc \ + testing/SetFilter.cc \ ##################### Network Sims ############################## # to be ported over. diff --git a/tests/librssimulator/testing/SetFilter.cc b/tests/librssimulator/testing/SetFilter.cc new file mode 100644 index 000000000..40d90f768 --- /dev/null +++ b/tests/librssimulator/testing/SetFilter.cc @@ -0,0 +1,67 @@ + +#include "SetFilter.h" + +bool SetFilter::filter(const SetPacket &pkt) +{ + switch(mFilterMode) + { + case FILTER_NONE: + return false; + break; + + case FILTER_ALL: + return true; + break; + + case FILTER_PARAMS: + // fall through to below. + break; + } + + // use params. + if (mUseSource) + { + std::set::const_iterator it; + it = mSources.find(pkt.mSrcId); + if (it == mSources.end()) + { + return false; + } + } + + if (mUseDest) + { + std::set::const_iterator it; + it = mDests.find(pkt.mDestId); + if (it == mDests.end()) + { + return false; + } + } + + if (mUseFullTypes) + { + std::set::const_iterator it; + it = mFullTypes.find(pkt.mItem->PacketId()); + if (it == mFullTypes.end()) + { + return false; + } + } + + if (mUseServiceTypes) + { + std::set::const_iterator it; + it = mServiceTypes.find(pkt.mItem->PacketService()); + if (it == mServiceTypes.end()) + { + return false; + } + } + return true; +} + + + + + diff --git a/tests/librssimulator/testing/SetFilter.h b/tests/librssimulator/testing/SetFilter.h new file mode 100644 index 000000000..9b9a8b15d --- /dev/null +++ b/tests/librssimulator/testing/SetFilter.h @@ -0,0 +1,55 @@ +#pragma once + +#include +#include "retroshare/rsids.h" +#include "SetPacket.h" + +class RsItem; + +class SetFilter +{ + public: + + enum FilterMode { + FILTER_NONE, + FILTER_ALL, + FILTER_PARAMS + }; + + SetFilter() + :mFilterMode(FILTER_ALL), + mUseSource(false), mUseDest(false), + mUseFullTypes(false), mUseServiceTypes(false) { return; } + + SetFilter(FilterMode mode) + :mFilterMode(mode), + mUseSource(false), mUseDest(false), + mUseFullTypes(false), mUseServiceTypes(false) { return; } + + void setFilterMode(FilterMode mode) { mFilterMode = mode; } + void setUseSource(bool toUse) { mUseSource = toUse; } + void setUseDest(bool toUse) { mUseDest = toUse; } + void setUseFullTypes(bool toUse) { mUseFullTypes = toUse; } + void setUseServiceTypes(bool toUse) { mUseServiceTypes = toUse; } + void addSource(const RsPeerId &id) { mSources.insert(id); } + void addDest(const RsPeerId &id) { mDests.insert(id); } + void addFullType(const uint32_t t) { mFullTypes.insert(t); } + void addServiceType(const uint16_t t) { mServiceTypes.insert(t); } + + virtual bool filter(const SetPacket &pkt); + + private: + + // capture parameters. + FilterMode mFilterMode; + bool mUseSource; + std::set mSources; + bool mUseDest; + std::set mDests; + bool mUseFullTypes; + std::set mFullTypes; + bool mUseServiceTypes; + std::set mServiceTypes; +}; + + diff --git a/tests/librssimulator/testing/SetPacket.h b/tests/librssimulator/testing/SetPacket.h new file mode 100644 index 000000000..ae529f37b --- /dev/null +++ b/tests/librssimulator/testing/SetPacket.h @@ -0,0 +1,27 @@ +#pragma once + +#include "pqi/p3linkmgr.h" // for RsPeerId ?? + +#include +#include "retroshare/rsids.h" + +class RsItem; + +class SetPacket +{ +public: + SetPacket(double t, const RsPeerId &srcId, + const RsPeerId &destId, RsItem *item) + :mTime(t), mSrcId(srcId), mDestId(destId), mItem(item) + { + return; + } + + SetPacket() :mTime(), mItem(NULL) { return; } + + double mTime; // relative to test creation; + RsPeerId mSrcId; + RsPeerId mDestId; + RsItem *mItem; +}; + diff --git a/tests/librssimulator/testing/SetServiceTester.cc b/tests/librssimulator/testing/SetServiceTester.cc new file mode 100644 index 000000000..ecda8283e --- /dev/null +++ b/tests/librssimulator/testing/SetServiceTester.cc @@ -0,0 +1,367 @@ + +#include +#include "retroshare/rsids.h" +#include "serialiser/rsserial.h" + +#include "SetServiceTester.h" +#include "peer/PeerNode.h" + +SetServiceTester::SetServiceTester() +:mDropFilter(SetFilter::FILTER_NONE), + mCaptureFilter(SetFilter::FILTER_ALL), + mFinishFilter(SetFilter::FILTER_NONE) +{ + mRsSerialiser = new RsSerialiser(); + mRefTime = time(NULL); +} + +SetServiceTester::~SetServiceTester() +{ + std::map::iterator pit; + for(pit = mNodes.begin(); pit != mNodes.end(); ++pit) + { + delete (pit->second); + } + mNodes.clear(); + + std::vector::iterator it; + for(it = mPackets.begin(); it != mPackets.end(); ++it) + { + delete it->mItem; + } + mPackets.clear(); + + delete mRsSerialiser; +} + +bool SetServiceTester::addNode(const RsPeerId &peerId, std::list friendIds) +{ + PeerNode *node = new PeerNode(peerId, friendIds, false); + mNodes[peerId] = node; + return true; +} + + +bool SetServiceTester::addNode(const RsPeerId &peerId, PeerNode *node) +{ + mNodes[peerId] = node; + return true; +} + +bool SetServiceTester::startup() +{ + std::map::iterator pit; + for(pit = mNodes.begin(); pit != mNodes.end(); ++pit) + { + pit->second->notifyOfFriends(); + } + return true; +} + + +bool SetServiceTester::bringOnline(const RsPeerId &peerId, std::list peers) +{ + std::map::iterator pit; + pit = mNodes.find(peerId); + if (pit != mNodes.end()) + { + pit->second->bringOnline(peers); + } + else + { + throw std::logic_error("SetServiceTester::bringOnline() invalid index"); + } + return true; +} + +/***************************************************************************************************/ +/***************************************************************************************************/ + + +uint32_t SetServiceTester::getPacketCount() +{ + return mPackets.size(); +} + +SetPacket &SetServiceTester::examinePacket(uint32_t idx) +{ + if (idx >= mPackets.size()) + { + throw std::logic_error("SetServiceTester::examinePacket() invalid index"); + } + return mPackets[idx]; +} + +bool SetServiceTester::injectPacket(const SetPacket &pkt) +{ + std::cerr << "SetServiceTester::injectPacket() Incomplete"; + std::cerr << std::endl; + + throw std::logic_error("SetServiceTester::injectPacket() incomplete"); + return false; +} + +uint32_t SetServiceTester::getNodeCount() +{ + return mNodes.size(); +} + +PeerNode * SetServiceTester::getPeerNode(const RsPeerId &id) +{ + std::map::iterator pit; + pit = mNodes.find(id); + if (pit == mNodes.end()) + { + throw std::logic_error("SetServiceTester::getPeerNode() invalid index"); + } + return pit->second; +} + + +/***************************************************************************************************/ +/***************************************************************************************************/ + +bool SetServiceTester::tick() +{ + tickUntilEvent(1, UNTIL_NONE); + return true; +} + +bool SetServiceTester::tickUntilCapturedPacket(int max_ticks, uint32_t& idx) +{ + bool eventOccured = tickUntilEvent(max_ticks, UNTIL_CAPTURE); + if (eventOccured) + { + idx = mPackets.size() - 1; + } + return eventOccured; +} + + +bool SetServiceTester::tickUntilFinish(int max_ticks) +{ + return tickUntilEvent(max_ticks, UNTIL_FINISH); +} + +bool SetServiceTester::tickUntilEvent(int max_ticks, EventType eventType) +{ + std::cerr << "SetServiceTester::tickUntilEvent()"; + std::cerr << std::endl; + + for(int i = 0; i < max_ticks; i++) + { + std::map::iterator pit; + for(pit = mNodes.begin(); pit != mNodes.end(); ++pit) + { + pit->second->tick(); + while (pit->second->haveOutgoingPackets()) + { + std::cerr << "SetServiceTester::tickUntilEvent() "; + std::cerr << "packet from: " << pit->first.toStdString(); + std::cerr << std::endl; + + bool finished = false; + double ts = time(NULL) - mRefTime; + RsRawItem *rawItem = pit->second->outgoing(); + RsItem *item = convertToRsItem(rawItem, false); + RsPeerId destId = rawItem->PeerId(); + RsPeerId srcId = pit->second->id(); + + SetPacket pkt(ts, srcId, destId, item); + if (filter(pkt)) + { + std::cerr << "Dropping Packet: "; + std::cerr << std::endl; + item->print(std::cerr); + std::cerr << std::endl; + + delete rawItem; + delete item; + continue; + } + + if (eventType == UNTIL_FINISH) + { + if (finish(pkt)) + { + std::cerr << "Finish Packet: "; + std::cerr << std::endl; + item->print(std::cerr); + std::cerr << std::endl; + + finished = true; + } + } + + if (capture(pkt)) + { + std::cerr << "Capture Packet: "; + std::cerr << std::endl; + item->print(std::cerr); + std::cerr << std::endl; + + mPackets.push_back(pkt); + if (eventType == UNTIL_CAPTURE) + { + finished = true; + } + } + else + { + delete item; + } + + // Pass on Item. + if (rawItem) + { + rawItem->PeerId(srcId); + std::map::iterator pit2; + pit2 = mNodes.find(destId); + if (pit2 != mNodes.end()) + { + pit2->second->incoming(rawItem); + } + else + { + // Error. + delete rawItem; + throw std::logic_error("SetServiceTester::tickUntilEvent() invalid destId"); + } + } + + if (finished) + { + return true; + } + } + } + } + return false; +} + + +/***************************************************************************************************/ +/***************************************************************************************************/ + +bool SetServiceTester::filter(const SetPacket& packet) +{ + return mDropFilter.filter(packet); +} + +bool SetServiceTester::capture(const SetPacket& packet) +{ + return mCaptureFilter.filter(packet); +} + +bool SetServiceTester::finish(const SetPacket& packet) +{ + return mFinishFilter.filter(packet); +} + +/***************************************************************************************************/ +/***************************************************************************************************/ + +void SetServiceTester::addSerialType(RsSerialType *st) +{ + mRsSerialiser->addSerialType(st); +} + + + +RsItem *SetServiceTester::convertToRsItem(RsRawItem *rawitem, bool toDelete) +{ + if (rawitem) + { + /* convert back to standard item for convenience */ + std::cerr << "SetServiceTester::getPacket() have RsRawItem"; + std::cerr << std::endl; + + /* convert to RsServiceItem */ + uint32_t size = rawitem->getRawLength(); + RsItem *item = mRsSerialiser->deserialise(rawitem->getRawData(), &size); + if ((!item) || (size != rawitem->getRawLength())) + { + /* error in conversion */ + std::cerr << "SetServiceTester::getPacket() Error"; + std::cerr << std::endl; + std::cerr << "SetServiceTester::getPacket() Size: " << size; + std::cerr << std::endl; + std::cerr << "SetServiceTester::getPacket() RawLength: " << rawitem->getRawLength(); + std::cerr << std::endl; + if (item) + { + std::cerr << "p3Service::recv() Bad Item:"; + std::cerr << std::endl; + item->print(std::cerr, 0); + std::cerr << std::endl; + + delete item; + item=NULL ; + } + } + else + { + item->PeerId(rawitem->PeerId()); + } + + if (toDelete) + { + delete rawitem; + } + return item; + } + return NULL; +} + +RsRawItem *SetServiceTester::convertToRsRawItem(RsItem *item, bool toDelete) +{ + std::cerr << "SetServiceTester::convertToRawItem()"; + std::cerr << std::endl; + + /* try to convert */ + uint32_t size = mRsSerialiser->size(item); + if (!size) + { + std::cerr << "SetServiceTesterconvertToRsRawItem() ERROR size == 0"; + std::cerr << std::endl; + + /* can't convert! */ + if (toDelete) + { + delete item; + } + return NULL; + } + + RsRawItem *raw = new RsRawItem(item->PacketId(), size); + if (!mRsSerialiser->serialise(item, raw->getRawData(), &size)) + { + std::cerr << "SetServiceTesterconvertToRsRawItem() ERROR serialise failed"; + std::cerr << std::endl; + + delete raw; + raw = NULL; + } + + if ((raw) && (size != raw->getRawLength())) + { + std::cerr << "SetServiceTesterconvertToRsRawItem() ERROR serialise size mismatch"; + std::cerr << std::endl; + + delete raw; + raw = NULL; + } + + if (raw) + { + raw->PeerId(item->PeerId()); + } + + if (toDelete) + { + delete item; + } + return raw; +} + + diff --git a/tests/librssimulator/testing/SetServiceTester.h b/tests/librssimulator/testing/SetServiceTester.h new file mode 100644 index 000000000..ed0ea902d --- /dev/null +++ b/tests/librssimulator/testing/SetServiceTester.h @@ -0,0 +1,78 @@ +#pragma once + +#include +#include "retroshare/rsids.h" +#include "pqi/p3linkmgr.h" + +#include "SetPacket.h" +#include "SetFilter.h" + +class RsItem; +class PeerNode; +class RsSerialType; +class RsSerialiser; + +class SetServiceTester +{ +public: + SetServiceTester(); + ~SetServiceTester(); + + enum EventType { + UNTIL_CAPTURE = 0, + UNTIL_FINISH, + UNTIL_NONE + }; + + bool addNode(const RsPeerId &peerId, std::list friendIds); + bool addNode(const RsPeerId &peerId, PeerNode *node); + + void addSerialType(RsSerialType *st); + bool startup(); + + bool bringOnline(const RsPeerId &peerId, std::list peers); + + bool tick(); + bool tickUntilCapturedPacket(int max_ticks, uint32_t &idx); + bool tickUntilFinish(int max_ticks); + + // return true, if we not transmit it. + virtual bool filter(const SetPacket& packet); + + // return true, if we should save it. + virtual bool capture(const SetPacket& packet); + + // return true to finish. + virtual bool finish(const SetPacket& packet); + + uint32_t getPacketCount(); + SetPacket &examinePacket(uint32_t idx); + bool injectPacket(const SetPacket &pkt); + + uint32_t getNodeCount(); + PeerNode *getPeerNode(const RsPeerId &id); + + SetFilter &getDropFilter() { return mDropFilter; } + SetFilter &getCaptureFilter() { return mCaptureFilter; } + SetFilter &getFinishFilter() { return mFinishFilter; } + +private: + + bool tickUntilEvent(int max_ticks, EventType eventType); + + RsItem *convertToRsItem(RsRawItem *rawitem, bool toDelete); + RsRawItem *convertToRsRawItem(RsItem *item, bool toDelete); + + + time_t mRefTime; + std::map mNodes; + RsSerialiser *mRsSerialiser; + std::vector mPackets; + + SetFilter mDropFilter; + SetFilter mCaptureFilter; + SetFilter mFinishFilter; +}; + + +