debugged rsnxsitem and serialiser

added test serialiser test suite 
updated support.cc to handle variable service types and RsTlvBinaryData init_item


git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-new_cache_system@5148 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libretroshare/src/tests/serialiser/rsnxsitems_test.cc

@@ -0,0 +1,222 @@
+
+#include "support.h"
+
+#include "rsnxsitems_test.h"
+
+INITTEST();
+
+#define NUM_BIN_OBJECTS 5
+#define NUM_SYNC_MSGS 8
+#define NUM_SYNC_GRPS 5
+
+RsSerialType* init_item(RsGrpResp& rgr)
+{
+
+    rgr.clear();
+
+    for(int i=0; i < 5; i++){
+        RsTlvBinaryData* b = new RsTlvBinaryData(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
+        init_item(*b);
+        rgr.grps.push_back(b);
+    }
+
+    return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
+}
+
+
+RsSerialType* init_item(RsGrpMsgResp& rgmr)
+{
+    rgmr.clear();
+
+    for(int i=0; i < 5; i++){
+        RsTlvBinaryData* b = new RsTlvBinaryData(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
+        init_item(*b);
+        rgmr.msgs.push_back(b);
+    }
+
+    return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
+}
+
+RsSerialType* init_item(RsSyncGrp& rsg)
+{
+    rsg.clear();
+
+    rsg.flag = RsSyncGrp::FLAG_USE_SYNC_HASH;
+    rsg.syncAge = rand()%2423;
+    randString(3124,rsg.syncHash);
+
+    return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
+}
+
+RsSerialType* init_item(RsSyncGrpMsg& rsgm)
+{
+    rsgm.clear();
+
+    rsgm.flag = RsSyncGrpMsg::FLAG_USE_SYNC_HASH;
+    rsgm.syncAge = rand()%24232;
+    randString(SHORT_STR, rsgm.grpId);
+    randString(SHORT_STR, rsgm.syncHash);
+
+    return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
+}
+
+RsSerialType* init_item(RsSyncGrpList& rsgl)
+{
+    rsgl.clear();
+
+    rsgl.flag = RsSyncGrpList::FLAG_RESPONSE;
+
+    for(int i=0; i < NUM_SYNC_GRPS; i++){
+
+        int nVers = rand()%8;
+        std::list<uint32_t> verL;
+        for(int j=0; j < nVers; j++){
+            verL.push_back(rand()%343);
+        }
+        std::string grpId;
+        randString(SHORT_STR, grpId);
+
+        std::pair<std::string, std::list<uint32_t> > p(grpId, verL);
+        rsgl.grps.insert(p);
+    }
+    return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
+}
+
+RsSerialType* init_item(RsSyncGrpMsgList& rsgml)
+{
+    rsgml.clear();
+
+    rsgml.flag = RsSyncGrpList::FLAG_RESPONSE;
+    randString(SHORT_STR, rsgml.grpId);
+
+    for(int i=0; i < NUM_SYNC_GRPS; i++){
+
+        int nVers = rand()%8;
+        std::list<uint32_t> verL;
+        for(int j=0; j < nVers; j++){
+            verL.push_back(rand()%343);
+        }
+        std::string msgId;
+        randString(SHORT_STR, msgId);
+
+        std::pair<std::string, std::list<uint32_t> > p(msgId, verL);
+        rsgml.msgs.insert(p);
+    }
+    return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
+}
+
+
+bool operator==(const RsGrpResp& l, const RsGrpResp& r){
+
+    if(l.grps.size() != r.grps.size()) return false;
+
+    std::list<RsTlvBinaryData*>::const_iterator lit
+            = l.grps.begin(), rit  =
+              r.grps.begin();
+
+    for(; lit != l.grps.end(); lit++, rit++){
+        if(!(*(*lit) == *(*rit))) return false;
+    }
+
+    return true;
+}
+
+bool operator==(const RsGrpMsgResp& l, const RsGrpMsgResp& r){
+
+    if(l.msgs.size() != r.msgs.size()) return false;
+
+    std::list<RsTlvBinaryData*>::const_iterator lit
+            = l.msgs.begin(), rit  =
+              r.msgs.begin();
+
+    for(; lit != l.msgs.end(); lit++, rit++){
+        if(!(*(*lit) == *(*rit))) return false;
+    }
+
+    return true;
+}
+
+bool operator==(const RsSyncGrp& l, const RsSyncGrp& r)
+{
+
+    if(l.syncHash != r.syncHash) return false;
+    if(l.flag != r.flag) return false;
+    if(l.syncAge != r.syncAge) return false;
+
+    return true;
+}
+
+bool operator==(const RsSyncGrpMsg& l, const RsSyncGrpMsg& r)
+{
+
+    if(l.flag != r.flag) return false;
+    if(l.syncAge != r.syncAge) return false;
+    if(l.syncHash != r.syncHash) return false;
+    if(l.grpId != r.grpId) return false;
+
+    return true;
+}
+
+bool operator==(const RsSyncGrpList& l, const RsSyncGrpList& r)
+{
+    if(l.flag != r.flag) return false;
+
+    SyncList::const_iterator lit = l.grps.begin(), rit= r.grps.begin();
+
+    for(; lit != l.grps.end(); lit++, rit++){
+
+        if(lit->first != rit->first) return false;
+        const std::list<uint32_t>& lList = lit->second, &rList
+                = rit->second;
+
+        std::list<uint32_t>::const_iterator lit2 = lList.begin(), rit2
+                                   = rList.begin();
+
+        for(; lit2 != lList.end(); lit2++, rit2++){
+
+            if(*lit2 != *rit2) return false;
+        }
+    }
+    return true;
+}
+
+bool operator==(const RsSyncGrpMsgList& l, const RsSyncGrpMsgList& r)
+{
+    if(l.flag != r.flag) return false;
+    if(l.grpId != r.grpId) return false;
+
+    SyncList::const_iterator lit = l.msgs.begin(), rit= r.msgs.begin();
+
+    for(; lit != l.msgs.end(); lit++, rit++){
+
+        if(lit->first != rit->first) return false;
+        const std::list<uint32_t>& lList = lit->second, &rList
+                = rit->second;
+
+        std::list<uint32_t>::const_iterator lit2 = lList.begin(), rit2
+                                   = rList.begin();
+
+        for(; lit2 != lList.end(); lit2++, rit2++){
+
+            if(*lit2 != *rit2) return false;
+        }
+    }
+
+    return true;
+}
+
+int main()
+{
+    std::cerr << "RsNxsItem Tests" << std::endl;
+
+    test_RsItem<RsGrpResp>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsGrpResp");
+    test_RsItem<RsGrpMsgResp>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsGrpMsgResp");
+    test_RsItem<RsSyncGrp>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrp");
+    test_RsItem<RsSyncGrpMsg>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpMsg");
+    test_RsItem<RsSyncGrpList>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpList");
+    test_RsItem<RsSyncGrpMsgList>(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); REPORT("Serialise/Deserialise RsSyncGrpMsgList");
+
+    FINALREPORT("RsNxsItem Tests");
+
+    return TESTRESULT();
+}

libretroshare/src/tests/serialiser/rsnxsitems_test.h

@@ -0,0 +1,22 @@
+#ifndef RSNXSITEMS_TEST_H
+#define RSNXSITEMS_TEST_H
+
+#include "serialiser/rsnxsitems.h"
+
+
+RsSerialType* init_item(RsGrpResp&);
+RsSerialType* init_item(RsGrpMsgResp&);
+RsSerialType* init_item(RsSyncGrp&);
+RsSerialType* init_item(RsSyncGrpMsg&);
+RsSerialType* init_item(RsSyncGrpList&);
+RsSerialType* init_item(RsSyncGrpMsgList&);
+
+bool operator==(const RsGrpResp&, const RsGrpResp&);
+bool operator==(const RsGrpMsgResp&, const RsGrpMsgResp&);
+bool operator==(const RsSyncGrp&, const RsSyncGrp&);
+bool operator==(const RsSyncGrpMsg&, const RsSyncGrpMsg&);
+bool operator==(const RsSyncGrpList&, const RsSyncGrpList&);
+bool operator==(const RsSyncGrpMsgList&, const RsSyncGrpMsgList&);
+
+
+#endif // RSNXSITEMS_TEST_H

libretroshare/src/tests/serialiser/support.cc

@@ -223,6 +223,13 @@ void init_item(RsTlvFileItem& fi)
 	return;
 }
 
+void init_item(RsTlvBinaryData& bd){
+    bd.TlvClear();
+    std::string data;
+    randString(LARGE_STR, data);
+    bd.setBinData(data.data(), data.length());
+}
+
 void init_item(RsTlvFileSet& fSet){
 
 	randString(LARGE_STR, fSet.comment);

libretroshare/src/tests/serialiser/support.h

@@ -157,5 +157,67 @@ template<class T> int test_RsItem()
 	return 1;
 }
 
+template<class T> int test_RsItem(uint16_t servtype)
+{
+        /* make a serialisable RsTurtleItem */
 
+        RsSerialiser srl;
+
+        /* initialise */
+        T rsfi(servtype) ;
+        RsSerialType *rsfis = init_item(rsfi) ;
+
+        /* attempt to serialise it before we add it to the serialiser */
+
+        CHECK(0 == srl.size(&rsfi));
+
+        static const uint32_t MAX_BUFSIZE = 22000 ;
+
+        char *buffer = new char[MAX_BUFSIZE];
+        uint32_t sersize = MAX_BUFSIZE;
+
+        CHECK(false == srl.serialise(&rsfi, (void *) buffer, &sersize));
+
+        /* now add to serialiser */
+
+        srl.addSerialType(rsfis);
+
+        uint32_t size = srl.size(&rsfi);
+        bool done = srl.serialise(&rsfi, (void *) buffer, &sersize);
+
+        std::cerr << "test_Item() size: " << size << std::endl;
+        std::cerr << "test_Item() done: " << done << std::endl;
+        std::cerr << "test_Item() sersize: " << sersize << std::endl;
+
+        std::cerr << "test_Item() serialised:" << std::endl;
+        //displayRawPacket(std::cerr, (void *) buffer, sersize);
+
+        CHECK(done == true);
+
+        uint32_t sersize2 = sersize;
+        RsItem *output = srl.deserialise((void *) buffer, &sersize2);
+
+        CHECK(output != NULL);
+        CHECK(sersize2 == sersize);
+
+        T *outfi = dynamic_cast<T *>(output);
+
+        CHECK(outfi != NULL);
+
+        if (outfi)
+                CHECK(*outfi == rsfi) ;
+
+        sersize2 = MAX_BUFSIZE;
+        bool done2 = srl.serialise(outfi, (void *) &(buffer[16*8]), &sersize2);
+
+        CHECK(done2) ;
+        CHECK(sersize2 == sersize);
+
+//	displayRawPacket(std::cerr, (void *) buffer, 16 * 8 + sersize2);
+
+        delete[] buffer ;
+        //delete rsfis;
+
+        return 1;
+}
 #endif /* SUPPORT_H_ */