From 2a5854188ea1c3c57f2e57fdfbc43ffebae090ef Mon Sep 17 00:00:00 2001 From: drbob Date: Sat, 5 Apr 2014 07:27:18 +0000 Subject: [PATCH] Added new test structure for libretroshare ported some of the tests across. git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@7233 b45a01b8-16f6-495d-af2f-9b41ad6348cc --- .../libretroshare/dbase/ficachetest.cc | 208 ++++++ .../libretroshare/dbase/fimontest.cc | 99 +++ .../libretroshare/dbase/fisavetest.cc | 127 ++++ .../unittests/libretroshare/dbase/fitest2.cc | 227 +++++++ .../libretroshare/dbase/searchtest.cc | 80 +++ .../libretroshare/gxs/common/data_support.cc | 270 ++++++++ .../libretroshare/gxs/common/data_support.h | 31 + .../gxs/data_service/rsdataservice_test.cc | 335 ++++++++++ .../gxs/data_service/rsdataservice_test.h | 33 + .../gxs/data_service/rsgxsdata_test.cc | 41 ++ .../gxs/gen_exchange/genexchange_test.pro | 180 ++++++ .../gxs/gen_exchange/genexchangetester.cc | 592 ++++++++++++++++++ .../gxs/gen_exchange/genexchangetester.h | 278 ++++++++ .../gen_exchange/genexchangetestservice.cc | 105 ++++ .../gxs/gen_exchange/genexchangetestservice.h | 99 +++ .../gxs/gen_exchange/gxsmsgrelatedtest.cc | 18 + .../gxs/gen_exchange/gxsmsgrelatedtest.h | 25 + .../gxs/gen_exchange/gxspublishgrouptest.cc | 301 +++++++++ .../gxs/gen_exchange/gxspublishgrouptest.h | 36 ++ .../gxs/gen_exchange/gxspublishmsgtest.cc | 76 +++ .../gxs/gen_exchange/gxspublishmsgtest.h | 32 + .../gxs/gen_exchange/rsdummyservices.cc | 226 +++++++ .../gxs/gen_exchange/rsdummyservices.h | 167 +++++ .../gxs/gen_exchange/rsgenexchange_test.cc | 41 ++ .../libretroshare/gxs/nxs_test/nxstesthub.cc | 130 ++++ .../libretroshare/gxs/nxs_test/nxstesthub.h | 89 +++ .../gxs/nxs_test/nxstestscenario.cc | 177 ++++++ .../gxs/nxs_test/nxstestscenario.h | 106 ++++ .../gxs/nxs_test/rsgxsnetservice_test.cc | 46 ++ .../serialiser/rsbaseitem_test.cc | 157 +++++ .../serialiser/rsconfigitem_test.cc | 305 +++++++++ .../serialiser/rsgrouteritem_test.cc | 209 +++++++ .../serialiser/rsgxsiditem_test.cc | 58 ++ .../serialiser/rsgxsupdateitem_test.cc | 105 ++++ .../serialiser/rsmsgitem_test.cc | 352 +++++++++++ .../serialiser/rsnxsitems_test.cc | 21 + .../serialiser/rsphotoitem_test.cc | 133 ++++ .../serialiser/rsstatusitem_test.cc | 52 ++ .../libretroshare/serialiser/rstlvutil.cc | 177 ++++++ .../libretroshare/serialiser/rstlvutil.h | 48 ++ .../serialiser/rsturtleitem_test.cc | 249 ++++++++ .../libretroshare/serialiser/support.cc | 328 ++++++++++ .../libretroshare/serialiser/support.h | 246 ++++++++ .../libretroshare/serialiser/tlvbase_test.cc | 172 +++++ .../libretroshare/serialiser/tlvbase_test2.cc | 158 +++++ .../libretroshare/serialiser/tlvitems_test.cc | 66 ++ .../libretroshare/serialiser/tlvkey_test.cc | 24 + .../serialiser/tlvrandom_test.cc | 184 ++++++ .../libretroshare/serialiser/tlvstack_test.cc | 87 +++ .../libretroshare/serialiser/tlvtypes_test.cc | 303 +++++++++ tests/unittests/unittests.cc | 8 + tests/unittests/unittests.pro | 306 +++++++++ 52 files changed, 7923 insertions(+) create mode 100644 tests/unittests/libretroshare/dbase/ficachetest.cc create mode 100644 tests/unittests/libretroshare/dbase/fimontest.cc create mode 100644 tests/unittests/libretroshare/dbase/fisavetest.cc create mode 100644 tests/unittests/libretroshare/dbase/fitest2.cc create mode 100644 tests/unittests/libretroshare/dbase/searchtest.cc create mode 100644 tests/unittests/libretroshare/gxs/common/data_support.cc create mode 100644 tests/unittests/libretroshare/gxs/common/data_support.h create mode 100644 tests/unittests/libretroshare/gxs/data_service/rsdataservice_test.cc create mode 100644 tests/unittests/libretroshare/gxs/data_service/rsdataservice_test.h create mode 100644 tests/unittests/libretroshare/gxs/data_service/rsgxsdata_test.cc create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/genexchange_test.pro create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/genexchangetester.cc create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/genexchangetester.h create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/genexchangetestservice.cc create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/genexchangetestservice.h create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.cc create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.h create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/gxspublishgrouptest.cc create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/gxspublishgrouptest.h create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/gxspublishmsgtest.cc create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/gxspublishmsgtest.h create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/rsdummyservices.cc create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/rsdummyservices.h create mode 100644 tests/unittests/libretroshare/gxs/gen_exchange/rsgenexchange_test.cc create mode 100644 tests/unittests/libretroshare/gxs/nxs_test/nxstesthub.cc create mode 100644 tests/unittests/libretroshare/gxs/nxs_test/nxstesthub.h create mode 100644 tests/unittests/libretroshare/gxs/nxs_test/nxstestscenario.cc create mode 100644 tests/unittests/libretroshare/gxs/nxs_test/nxstestscenario.h create mode 100644 tests/unittests/libretroshare/gxs/nxs_test/rsgxsnetservice_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsbaseitem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsconfigitem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsgrouteritem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsgxsiditem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsgxsupdateitem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsmsgitem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsnxsitems_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsphotoitem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rsstatusitem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/rstlvutil.cc create mode 100644 tests/unittests/libretroshare/serialiser/rstlvutil.h create mode 100644 tests/unittests/libretroshare/serialiser/rsturtleitem_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/support.cc create mode 100644 tests/unittests/libretroshare/serialiser/support.h create mode 100644 tests/unittests/libretroshare/serialiser/tlvbase_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/tlvbase_test2.cc create mode 100644 tests/unittests/libretroshare/serialiser/tlvitems_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/tlvkey_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/tlvrandom_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/tlvstack_test.cc create mode 100644 tests/unittests/libretroshare/serialiser/tlvtypes_test.cc create mode 100644 tests/unittests/unittests.cc create mode 100644 tests/unittests/unittests.pro diff --git a/tests/unittests/libretroshare/dbase/ficachetest.cc b/tests/unittests/libretroshare/dbase/ficachetest.cc new file mode 100644 index 000000000..ea8ae2107 --- /dev/null +++ b/tests/unittests/libretroshare/dbase/ficachetest.cc @@ -0,0 +1,208 @@ +/* + * RetroShare FileCache Module: ficachetest.cc + * + * Copyright 2004-2007 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include "dbase/cachestrapper.h" +#include "dbase/cachetest.h" +#include "pqi/p3connmgr.h" + +#include +/********************************** WINDOWS/UNIX SPECIFIC PART ******************/ +#ifndef WINDOWS_SYS +#else + #include +#endif +/********************************** WINDOWS/UNIX SPECIFIC PART ******************/ + + +void handleQuery(CacheStrapper *csp, RsPeerId pid, + std::map &strappers); + +/* A simple test of the CacheStrapper Code. + * + * create 3 different CacheStrappers, each with a Source/Store Pair and Transfer Class. + * pass queries and responses between the CacheStrappers, + * and ensure that the hashes in the Caches are updated. + * + */ + +int main(int argc, char **argv) +{ + + time_t period = 11; + RsPeerId pid1("0x0101"); + RsPeerId pid2("0x0102"); + RsPeerId pid3("0x0103"); + + p3ConnectMgr *connMgr1 = new p3ConnectMgr(); + p3ConnectMgr *connMgr2 = connMgr1; + p3ConnectMgr *connMgr3 = connMgr1; + + CacheStrapper sc1(connMgr1); + CacheStrapper sc2(connMgr2); + CacheStrapper sc3(connMgr3); + CacheTransfer ctt1(&sc1); + CacheTransfer ctt2(&sc2); + CacheTransfer ctt3(&sc3); + + std::map strappers; + strappers[pid1] = &sc1; + strappers[pid2] = &sc2; + strappers[pid3] = &sc3; + + + std::string nulldir = ""; + + CacheSource *csrc1 = new CacheTestSource(&sc1, nulldir); + CacheStore *cstore1 = new CacheTestStore(&ctt1, &sc1, nulldir); + CacheId cid1(TESTID, 0); + + CacheSource *csrc2 = new CacheTestSource(&sc2, nulldir); + CacheStore *cstore2 = new CacheTestStore(&ctt2, &sc2, nulldir); + CacheId cid2(TESTID, 0); + + CacheSource *csrc3 = new CacheTestSource(&sc3, nulldir); + CacheStore *cstore3 = new CacheTestStore(&ctt3, &sc3, nulldir); + CacheId cid3(TESTID, 0); + + CachePair cp1(csrc1, cstore1, cid1); + CachePair cp2(csrc2, cstore2, cid2); + CachePair cp3(csrc3, cstore3, cid3); + + sc1.addCachePair(cp1); + sc2.addCachePair(cp2); + sc3.addCachePair(cp3); + + /* add in a cache to sc2 */ + RsCacheData cdata; + + cdata.pid = pid1; + cdata.cid = cid1; + cdata.name = "Perm Cache"; + cdata.path = "./"; + cdata.hash = "GHJKI"; + + csrc1->refreshCache(cdata); + + cdata.pid = pid2; + cdata.cid = cid2; + cdata.name = "Funny Cache"; + cdata.path = "./"; + cdata.hash = "ABCDEF"; + + csrc2->refreshCache(cdata); + + /* now exercise it */ + + for(int i = 0; 1 ; i++) + { + RsPeerId src(""); + CacheStrapper *csp = NULL; + + if (i % 5 == 1) + { + src = pid1; + csp = &sc1; + } + else if (i % 5 == 2) + { + src = pid2; + csp = &sc2; + } + else if (i % 5 == 3) + { + src = pid3; + csp = &sc3; + } + std::cerr << std::endl; + std::cerr << "Cache Iteraton: " << time(NULL) << std::endl; + std::cerr << std::endl; + + if (src != "") + { + handleQuery(csp, src, strappers); + } + + + if (i % 21 == 0) + { + /* print out the resources */ + sc1.listCaches(std::cerr); + sc2.listCaches(std::cerr); + sc3.listCaches(std::cerr); + } + + /* every once in a while change the cache on 2 */ + if (i % 31 == 25) + { + cdata.hash += "X"; + csrc2->refreshCache(cdata); + } + +/********************************** WINDOWS/UNIX SPECIFIC PART ******************/ +#ifndef WINDOWS_SYS + sleep(1); +#else + Sleep(1000); +#endif +/********************************** WINDOWS/UNIX SPECIFIC PART ******************/ + + /* tick the systems */ + + } + + /* Cleanup - TODO */ + + return 1; +} + +void handleQuery(CacheStrapper *csp, RsPeerId pid, + std::map &strappers) +{ + /* query */ + std::list ids; + std::list::iterator pit; + + std::cerr << "Cache Query from: " << pid << std::endl; + + //csp -> sendCacheQuery(ids, time(NULL)); + for(pit = ids.begin(); pit != ids.end(); pit++) + { + std::cerr << "Cache Query for: " << (*pit) << std::endl; + std::map::iterator sit; + if (strappers.end() != (sit = strappers.find(*pit))) + { + std::map hashs; + std::map::iterator hit; + (sit -> second) -> handleCacheQuery(pid, hashs); + for(hit = hashs.begin(); hit != hashs.end(); hit++) + { + csp -> recvCacheResponse(hit->second, time(NULL)); + } + } + else + { + std::cerr << "Unknown Query Destination!" << std::endl; + } + } +} + diff --git a/tests/unittests/libretroshare/dbase/fimontest.cc b/tests/unittests/libretroshare/dbase/fimontest.cc new file mode 100644 index 000000000..ec9e9989b --- /dev/null +++ b/tests/unittests/libretroshare/dbase/fimontest.cc @@ -0,0 +1,99 @@ +/* + * RetroShare FileCache Module: fimontest.cc + * + * Copyright 2004-2007 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +//#include "pqi/p3connmgr.h" +#include "retroshare/rsiface.h" +#include "dbase/cachestrapper.h" +#include "dbase/findex.h" +#include "dbase/fimonitor.h" + +#include + +void usage(char *name) +{ + std::cerr << "Usage: " << name << " [-p ] shareDir1 [shareDir2 [shareDir3 [...]]]"; + std::cerr << std::endl; + exit(1); +} + + +/*! + * What is tested: + * 1. + * 2. + * 3. + */ +int main(int argc, char **argv) +{ + /* handle commandline arguments */ + int c; + int period = 60; /* recheck period in seconds */ + + while((c = getopt(argc, argv,"p:")) != -1) + { + switch(c) + { + case 'p': + period = atoi(optarg); + break; + default: + std::cerr << "Bad Option."; + std::cerr << std::endl; + usage(argv[0]); + break; + } + } + + std::list rootdirs; + + /* add all the rest of the commandline arguments to rootdirs list */ + for(; optind < argc; optind++) + { + SharedDirInfo dir; + dir.filename = argv[optind]; + dir.shareflags = DIR_FLAGS_PERMISSIONS_MASK ; + rootdirs.push_back(dir); + std::cerr << "Adding shared directory: " << argv[optind] << std::endl; + } + + if (rootdirs.size() < 1) + { + usage(argv[0]); + } + + //p3ConnectMgr connMgr; + NotifyBase nb; + CacheStrapper* cs = NULL; + + FileIndexMonitor mon(cs, &nb, "", "OWN ID", std::string(".")); + + /* setup monitor */ + mon.setSharedDirectories(rootdirs); + + /* simulate running the thread */ + mon.run(); + + return 1; +} + + diff --git a/tests/unittests/libretroshare/dbase/fisavetest.cc b/tests/unittests/libretroshare/dbase/fisavetest.cc new file mode 100644 index 000000000..3ef7bf3ca --- /dev/null +++ b/tests/unittests/libretroshare/dbase/fisavetest.cc @@ -0,0 +1,127 @@ +/* + * RetroShare FileCache Module: fisavetest.cc + * + * Copyright 2004-2007 by Kefei Zhou. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include "dbase/findex.h" +#include + +static FileIndex *createBasicFileIndex(time_t age); + +TEST(libretroshare_dbase, SaveTest) +{ + RsPeerId peerId; + peerId.random(); + FileIndex *fi1 = createBasicFileIndex(100); + FileIndex *fi2 = new FileIndex(peerId); + + std::string out ; + fi1->printFileIndex(out); + std::cout << out < forbiddenroots; + fi1->saveIndex("test.index", fhash, size, forbiddenroots); + + std::cout << " Saved Index: Size: " << size << " Hash: " << fhash << std::endl; + std::cout << " -- new file index -- " << std::endl; + + fi2->loadIndex("test.index", fhash, size); + out.clear() ; + fi2->printFileIndex(out); + std::cout << out << std::endl; + + delete fi1; + delete fi2; +} + + +FileIndex *createBasicFileIndex(time_t age) +{ + RsPeerId peerId; + peerId.random(); + FileIndex *fi = new FileIndex(peerId); + + FileEntry fe; + + std::list rootdirs; + rootdirs.push_back("base1"); + rootdirs.push_back("base2"); + rootdirs.push_back("base3"); + + fi -> setRootDirectories(rootdirs, age); + + /* add some entries */ + fe.name = "dir1"; + fi -> updateDirEntry("base1",fe, age); + fe.name = "dir2"; + fi -> updateDirEntry("base1",fe, age); + + fe.name = "dir01"; + fi -> updateDirEntry("/base1/dir1/",fe, age); + + fe.name = "dir001"; + fi -> updateDirEntry("/base1/dir1/dir01/",fe, age); + + fe.name = "file1"; + fi -> updateFileEntry("/base1/dir1/",fe, age); + fe.name = "file2"; + fi -> updateFileEntry("/base1/dir1/",fe, age); + fe.name = "file3"; + fi -> updateFileEntry("/base1/dir1/",fe, age); + fe.name = "file4"; + fi -> updateFileEntry("/base1/dir1/",fe, age); + + + fe.name = "dir2"; + fi -> updateDirEntry("/base1",fe, age); + fe.name = "file5"; + fi -> updateFileEntry("/base1/dir2/",fe, age); + fe.name = "file6"; + fi -> updateFileEntry("/base1/dir2/",fe, age); + fe.name = "file7"; + fi -> updateFileEntry("/base1/dir2/",fe, age); + fe.name = "file8"; + fi -> updateFileEntry("/base1/",fe, age); + + + fe.name = "dir3"; + fi -> updateDirEntry("/base1/dir2/",fe, age); + fe.name = "file10"; + fi -> updateFileEntry("/base1/dir2/dir3",fe, age); + fe.name = "file11"; + fi -> updateFileEntry("/base1/dir2/dir3",fe, age); + fe.name = "file12"; + fi -> updateFileEntry("/base1/dir2/dir3",fe, age); + + + fe.name = "dir4"; + fi -> updateDirEntry("/base3/",fe, age); + fe.name = "file20"; + fi -> updateFileEntry("/base3/dir4/",fe, age); + fe.name = "file21"; + fi -> updateFileEntry("/base3/dir4",fe, age); + + return fi; +} + diff --git a/tests/unittests/libretroshare/dbase/fitest2.cc b/tests/unittests/libretroshare/dbase/fitest2.cc new file mode 100644 index 000000000..789f3e97b --- /dev/null +++ b/tests/unittests/libretroshare/dbase/fitest2.cc @@ -0,0 +1,227 @@ +/* + * RetroShare FileCache Module: fitest2.cc + * + * Copyright 2004-2007 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include +#include "dbase/findex.h" + +#include + +static FileIndex *createBasicFileIndex(time_t age); + +int test1(FileIndex *fi); +int test2(FileIndex *fi); + +TEST(libretroshare_dbase, FiTest2) +{ + FileIndex *fi = createBasicFileIndex(100); + + test1(fi); + + delete fi; +} + +int test1(FileIndex *fi) +{ + /* in this test we are going to get the old directories - and update them */ + time_t stamp = 200; + + DirEntry *olddir = NULL; + FileEntry fe; + while((olddir = fi -> findOldDirectory(stamp))) + { + /* update the directories and files here */ + std::map::iterator dit; + std::map::iterator fit; + + /* update this dir */ + fe.name = olddir->name; + fi -> updateDirEntry(olddir->parent->path, fe, stamp); + + /* update subdirs */ + for(dit = olddir->subdirs.begin(); dit != olddir->subdirs.end(); dit++) + { + fe.name = (dit->second)->name; + /* set the age as out-of-date so that it gets checked */ + fi -> updateDirEntry(olddir->path, fe, 0); + } + + /* update files */ + for(fit = olddir->files.begin(); fit != olddir->files.end(); fit++) + { + fe.name = (fit->second)->name; + fi -> updateFileEntry(olddir->path, fe, stamp); + } + + /* clean up the dir (should have no effect) */ + fi -> removeOldDirectory(olddir->parent->path, olddir->name, stamp); + + std::string out ; + fi -> printFileIndex(out); + std::cout << out << std::endl; + } + + std::string out ; + fi -> printFileIndex(out); + std::cout << out << std::endl; + + return 1; +} + + +int test2(FileIndex *fi) +{ + /* in this test we are going to simulate that 2 directories have disappeared */ + time_t stamp = 200; + + DirEntry *olddir = NULL; + FileEntry fe; + bool missingdir = false; + int i = 0; + + while((olddir = fi -> findOldDirectory(stamp))) + { + missingdir = false; + if (i % 2 == 0) + { + std::cerr << " Simulating that dir doesnt exist :" << olddir->path; + std::cerr << std::endl; + missingdir = true; + } + i++; + + if (!missingdir) + { + /* update the directories and files here */ + std::map::iterator dit; + std::map::iterator fit; + + /* update this dir */ + fe.name = olddir->name; + fi -> updateDirEntry(olddir->parent->path, fe, stamp); + + /* update subdirs */ + for(dit = olddir->subdirs.begin(); dit != olddir->subdirs.end(); dit++) + { + fe.name = (dit->second)->name; + /* set the age as out-of-date so that it gets checked */ + fi -> updateDirEntry(olddir->path, fe, 0); + } + + /* update files */ + for(fit = olddir->files.begin(); fit != olddir->files.end(); fit++) + { + fe.name = (fit->second)->name; + fi -> updateFileEntry(olddir->path, fe, stamp); + } + } + /* clean up the dir */ + fi -> removeOldDirectory(olddir->parent->path, olddir->name, stamp); + + std::string out ; + fi -> printFileIndex(out); + std::cout << out << std::endl; + } + + std::string out ; + fi -> printFileIndex(out); + std::cout << out << std::endl; + + return 1; +} + + + + + +FileIndex *createBasicFileIndex(time_t age) +{ + RsPeerId peerId; + peerId.random(); + FileIndex *fi = new FileIndex(peerId); + + FileEntry fe; + + /* print empty FileIndex */ + std::string out ; + fi -> printFileIndex(out); + std::cout << out << std::endl; + + std::list rootdirs; + rootdirs.push_back("base1"); + rootdirs.push_back("base2"); + rootdirs.push_back("base3"); + + fi -> setRootDirectories(rootdirs, age); + + /* add some entries */ + fe.name = "dir1"; + fi -> updateDirEntry("base1",fe, age); + fe.name = "file1"; + fi -> updateFileEntry("/base1/dir1/",fe, age); + fe.name = "file2"; + fi -> updateFileEntry("/base1/dir1/",fe, age); + fe.name = "file3"; + fi -> updateFileEntry("/base1/dir1/",fe, age); + fe.name = "file4"; + fi -> updateFileEntry("/base1/dir1/",fe, age); + + fe.name = "dir2"; + fi -> updateDirEntry("/base1",fe, age); + fe.name = "file5"; + fi -> updateFileEntry("/base1/dir2/",fe, age); + fe.name = "file6"; + fi -> updateFileEntry("/base1/dir2/",fe, age); + fe.name = "file7"; + fi -> updateFileEntry("/base1/dir2/",fe, age); + fe.name = "file8"; + fi -> updateFileEntry("/base1/",fe, age); + + + fe.name = "dir3"; + fi -> updateDirEntry("/base1/dir2/",fe, age); + fe.name = "file10"; + fi -> updateFileEntry("/base1/dir2/dir3",fe, age); + fe.name = "file11"; + fi -> updateFileEntry("/base1/dir2/dir3",fe, age); + fe.name = "file12"; + fi -> updateFileEntry("/base1/dir2/dir3",fe, age); + + + fe.name = "dir4"; + fi -> updateDirEntry("/base3/",fe, age); + fe.name = "file20"; + fi -> updateFileEntry("/base3/dir4/",fe, age); + fe.name = "file21"; + fi -> updateFileEntry("/base3/dir4",fe, age); + + // one that will fail. + fe.name = "file20"; + fi -> updateFileEntry("/base3/",fe, age); + + out.clear() ; + fi -> printFileIndex(out); + std::cout << out << std::endl; + + return fi; +} + diff --git a/tests/unittests/libretroshare/dbase/searchtest.cc b/tests/unittests/libretroshare/dbase/searchtest.cc new file mode 100644 index 000000000..58cd0ffc4 --- /dev/null +++ b/tests/unittests/libretroshare/dbase/searchtest.cc @@ -0,0 +1,80 @@ +/* + * RetroShare FileCache Module: searchtest.cc + * + * Copyright 2004-2007 by Kefei Zhou. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include "dbase/findex.h" +#include +#include + +TEST(libretroshare_dbase, SearchTest) +{ + RsPeerId peerId; + peerId.random(); + + std::cout << std::string::npos << std::endl; + std::string testfile = "searchtest.index"; + RsFileHash fhash("6851c28d99a6616a86942c3914476bf11997242a"); + FileIndex *fi = new FileIndex(peerId); + + // loading fileindex + std::cout << std::endl << "Test load" << std::endl; + fi->loadIndex(testfile, fhash, 1532); + fi->printFileIndex(std::cout); + std::cout << "FileIndex Loaded" << std::endl << std::endl; + + std::list hashresult; + std::list termresult; + + // searchhash + RsFileHash findhash("82bffa6e1cdf8419397311789391238174817481"); + + std::cout << "Search hash : " << findhash << std::endl; + fi->searchHash(findhash, hashresult); + + while(!hashresult.empty()) + { + std::string out ; + hashresult.back()->print(out); + std::cout << out << std::endl; + hashresult.pop_back(); + } + + // searchterm + std::list terms; + terms.push_back("paper"); + terms.push_back("doc"); + + std::cout << "Search terms" << std::endl; + fi->searchTerms(terms, termresult); + + while(!termresult.empty()) + { + std::string out ; + termresult.back()->print(out); + std::cout << out << std::endl; + termresult.pop_back(); + } + + delete fi; +} diff --git a/tests/unittests/libretroshare/gxs/common/data_support.cc b/tests/unittests/libretroshare/gxs/common/data_support.cc new file mode 100644 index 000000000..7652fce41 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/common/data_support.cc @@ -0,0 +1,270 @@ +#include "libretroshare/serialiser/support.h" +#include "data_support.h" + + +bool operator==(const RsNxsGrp& l, const RsNxsGrp& r){ + + if(l.grpId != r.grpId) return false; + if(!(l.grp == r.grp) ) return false; + if(!(l.meta == r.meta) ) return false; + if(l.transactionNumber != r.transactionNumber) return false; + + return true; +} + +bool operator==(const RsNxsMsg& l, const RsNxsMsg& r){ + + + if(l.msgId != r.msgId) return false; + if(l.grpId != r.grpId) return false; + if(! (l.msg == r.msg) ) return false; + if(! (l.meta == r.meta) ) return false; + if(l.transactionNumber != r.transactionNumber) return false; + + return true; +} + + +bool operator ==(const RsGxsGrpMetaData& l, const RsGxsGrpMetaData& r) +{ + if(!(l.signSet == r.signSet)) return false; + if(!(l.keys == r.keys)) return false; + if(l.mGroupFlags != r.mGroupFlags) return false; + if(l.mPublishTs != r.mPublishTs) return false; + if(l.mAuthorId != r.mAuthorId) return false; + if(l.mGroupName != r.mGroupName) return false; + if(l.mGroupId != r.mGroupId) return false; + + return true; +} + +bool operator ==(const RsGxsMsgMetaData& l, const RsGxsMsgMetaData& r) +{ + + if(!(l.signSet == r.signSet)) return false; + if(l.mGroupId != r.mGroupId) return false; + if(l.mAuthorId != r.mAuthorId) return false; + if(l.mParentId != r.mParentId) return false; + if(l.mOrigMsgId != r.mOrigMsgId) return false; + if(l.mThreadId != r.mThreadId) return false; + if(l.mMsgId != r.mMsgId) return false; + if(l.mMsgName != r.mMsgName) return false; + if(l.mPublishTs != r.mPublishTs) return false; + if(l.mMsgFlags != r.mMsgFlags) return false; + + return true; +} + + + +#if 0 +void init_item(RsNxsGrp& nxg) +{ + + nxg.clear(); + + nxg.grpId.random(); + nxg.transactionNumber = rand()%23; + init_item(nxg.grp); + init_item(nxg.meta); + return; +} + +void init_item(RsNxsMsg& nxm) +{ + nxm.clear(); + + nxm.msgId.random(); + nxm.grpId.random(); + init_item(nxm.msg); + init_item(nxm.meta); + nxm.transactionNumber = rand()%23; + + return; +} +#endif + + +void init_item(RsGxsGrpMetaData* metaGrp) +{ + + metaGrp->mGroupId.random(); + metaGrp->mOrigGrpId.random(); + metaGrp->mAuthorId.random(); + randString(SHORT_STR, metaGrp->mGroupName); + + init_item(metaGrp->signSet); + init_item(metaGrp->keys); + + metaGrp->mPublishTs = rand()%3452; + metaGrp->mGroupFlags = rand()%43; + + metaGrp->mGroupStatus = rand()%313; + metaGrp->mSubscribeFlags = rand()%2251; + metaGrp->mMsgCount = rand()%2421; + metaGrp->mLastPost = rand()%2211; + metaGrp->mPop = rand()%5262; +} + +void init_item(RsGxsMsgMetaData* metaMsg) +{ + + metaMsg->mGroupId.random(); + metaMsg->mMsgId.random(); + metaMsg->mThreadId.random(); + metaMsg->mParentId.random(); + metaMsg->mAuthorId.random(); + metaMsg->mOrigMsgId.random(); + randString(SHORT_STR, metaMsg->mMsgName); + + init_item(metaMsg->signSet); + + metaMsg->mPublishTs = rand()%313; + metaMsg->mMsgFlags = rand()%224; + metaMsg->mMsgStatus = rand()%4242; + metaMsg->mChildTs = rand()%221; +} + + + + +RsSerialType* init_item(RsNxsGrp& nxg) +{ + nxg.clear(); + + nxg.grpId.random(); + nxg.transactionNumber = rand()%23; + init_item(nxg.grp); + init_item(nxg.meta); + + return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + + +RsSerialType* init_item(RsNxsMsg& nxm) +{ + nxm.clear(); + + nxm.msgId.random(); + nxm.grpId.random(); + init_item(nxm.msg); + init_item(nxm.meta); + nxm.transactionNumber = rand()%23; + + return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +RsSerialType* init_item(RsNxsSyncGrp& rsg) +{ + rsg.clear(); + rsg.flag = RsNxsSyncGrp::FLAG_USE_SYNC_HASH; + rsg.createdSince = rand()%2423; + randString(3124,rsg.syncHash); + + return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +RsSerialType* init_item(RsNxsSyncMsg& rsgm) +{ + rsgm.clear(); + + rsgm.flag = RsNxsSyncMsg::FLAG_USE_SYNC_HASH; + rsgm.createdSince = rand()%24232; + rsgm.transactionNumber = rand()%23; + rsgm.grpId.random(); + randString(SHORT_STR, rsgm.syncHash); + + return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +RsSerialType* init_item(RsNxsSyncGrpItem& rsgl) +{ + rsgl.clear(); + + rsgl.flag = RsNxsSyncGrpItem::FLAG_RESPONSE; + rsgl.transactionNumber = rand()%23; + rsgl.publishTs = rand()%23; + rsgl.grpId.random(); + + return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +RsSerialType* init_item(RsNxsSyncMsgItem& rsgml) +{ + rsgml.clear(); + + rsgml.flag = RsNxsSyncGrpItem::FLAG_RESPONSE; + rsgml.transactionNumber = rand()%23; + rsgml.grpId.random(); + rsgml.msgId.random(); + + return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +RsSerialType* init_item(RsNxsTransac& rstx){ + + rstx.clear(); + + rstx.timestamp = rand()%14141; + rstx.transactFlag = rand()%2424; + rstx.nItems = rand()%33132; + rstx.transactionNumber = rand()%242112; + + return new RsNxsSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + + +bool operator==(const RsNxsSyncGrp& l, const RsNxsSyncGrp& r) +{ + + if(l.syncHash != r.syncHash) return false; + if(l.flag != r.flag) return false; + if(l.createdSince != r.createdSince) return false; + if(l.transactionNumber != r.transactionNumber) return false; + + return true; +} + +bool operator==(const RsNxsSyncMsg& l, const RsNxsSyncMsg& r) +{ + + if(l.flag != r.flag) return false; + if(l.createdSince != r.createdSince) return false; + if(l.syncHash != r.syncHash) return false; + if(l.grpId != r.grpId) return false; + if(l.transactionNumber != r.transactionNumber) return false; + + return true; +} + +bool operator==(const RsNxsSyncGrpItem& l, const RsNxsSyncGrpItem& r) +{ + if(l.flag != r.flag) return false; + if(l.publishTs != r.publishTs) return false; + if(l.grpId != r.grpId) return false; + if(l.transactionNumber != r.transactionNumber) return false; + + return true; +} + +bool operator==(const RsNxsSyncMsgItem& l, const RsNxsSyncMsgItem& r) +{ + if(l.flag != r.flag) return false; + if(l.grpId != r.grpId) return false; + if(l.msgId != r.msgId) return false; + if(l.transactionNumber != r.transactionNumber) return false; + + return true; +} + +bool operator==(const RsNxsTransac& l, const RsNxsTransac& r){ + + if(l.transactFlag != r.transactFlag) return false; + if(l.transactionNumber != r.transactionNumber) return false; + if(l.timestamp != r.timestamp) return false; + if(l.nItems != r.nItems) return false; + + + return true; +} + diff --git a/tests/unittests/libretroshare/gxs/common/data_support.h b/tests/unittests/libretroshare/gxs/common/data_support.h new file mode 100644 index 000000000..5c886a487 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/common/data_support.h @@ -0,0 +1,31 @@ +#pragma once + +#include "serialiser/rsnxsitems.h" +#include "gxs/rsgxsdata.h" + +#define RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM 0x012 + +bool operator==(const RsNxsGrp&, const RsNxsGrp&); +bool operator==(const RsNxsMsg&, const RsNxsMsg&); +bool operator==(const RsGxsGrpMetaData& l, const RsGxsGrpMetaData& r); +bool operator==(const RsGxsMsgMetaData& l, const RsGxsMsgMetaData& r); +bool operator==(const RsNxsSyncGrp& l, const RsNxsSyncGrp& r); +bool operator==(const RsNxsSyncMsg& l, const RsNxsSyncMsg& r); +bool operator==(const RsNxsSyncGrpItem& l, const RsNxsSyncGrpItem& r); +bool operator==(const RsNxsSyncMsgItem& l, const RsNxsSyncMsgItem& r); +bool operator==(const RsNxsTransac& l, const RsNxsTransac& r); + +//void init_item(RsNxsGrp& nxg); +//void init_item(RsNxsMsg& nxm); +void init_item(RsGxsGrpMetaData* metaGrp); +void init_item(RsGxsMsgMetaData* metaMsg); + + +RsSerialType* init_item(RsNxsGrp& nxg); +RsSerialType* init_item(RsNxsMsg& nxm); +RsSerialType* init_item(RsNxsSyncGrp& rsg); +RsSerialType* init_item(RsNxsSyncMsg& rsgm); +RsSerialType* init_item(RsNxsSyncGrpItem& rsgl); +RsSerialType* init_item(RsNxsSyncMsgItem& rsgml); +RsSerialType* init_item(RsNxsTransac& rstx); + diff --git a/tests/unittests/libretroshare/gxs/data_service/rsdataservice_test.cc b/tests/unittests/libretroshare/gxs/data_service/rsdataservice_test.cc new file mode 100644 index 000000000..e59e59ede --- /dev/null +++ b/tests/unittests/libretroshare/gxs/data_service/rsdataservice_test.cc @@ -0,0 +1,335 @@ + +#include + +#include "libretroshare/serialiser/support.h" +#include "libretroshare/gxs/common/data_support.h" +#include "rsdataservice_test.h" +#include "gxs/rsgds.h" +#include "gxs/rsdataservice.h" + +#define DATA_BASE_NAME "msg_grp_Store" + + +RsGeneralDataService* dStore = NULL; + +void setUp(); +void tearDown(); + +TEST(libretroshare_gxs, RsDataService) +{ + + std::cerr << "RsDataService Tests" << std::endl; + + test_groupStoreAndRetrieve(); + test_messageStoresAndRetrieve(); +} + + + +/*! + * All memory is disposed off, good for looking + * for memory leaks + */ +void test_groupStoreAndRetrieve(){ + + setUp(); + + int nGrp = rand()%32; + std::map grps, grps_copy; + RsNxsGrp* grp; + RsGxsGrpMetaData* grpMeta; + for(int i = 0; i < nGrp; i++){ + std::pair p; + grp = new RsNxsGrp(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + grpMeta = new RsGxsGrpMetaData(); + p.first = grp; + p.second = grpMeta; + init_item(*grp); + init_item(grpMeta); + grpMeta->mGroupId = grp->grpId; + grps.insert(p); + RsNxsGrp* grp_copy = new RsNxsGrp(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + *grp_copy = *grp; + RsGxsGrpMetaData* grpMeta_copy = new RsGxsGrpMetaData(); + *grpMeta_copy = *grpMeta; + grps_copy.insert(std::make_pair(grp_copy, grpMeta_copy )); + grpMeta = NULL; + grp = NULL; + } + + dStore->storeGroup(grps); + + //use copy, a grps are deleted in store + grps.clear(); + grps = grps_copy; + + std::map gR; + std::map grpMetaR; + dStore->retrieveNxsGrps(gR, false, false); + dStore->retrieveGxsGrpMetaData(grpMetaR); + + std::map::iterator mit = grps.begin(); + + bool grpMatch = true, grpMetaMatch = true; + + for(; mit != grps.end(); mit++) + { + const RsGxsGroupId grpId = mit->first->grpId; + + // check if it exists + if(gR.find(grpId) == gR.end()) { + grpMatch = false; + break; + } + + RsNxsGrp *l = mit->first, + *r = gR[grpId]; + + // assign transaction number + // to right to as tn is not stored + // in db + r->transactionNumber = l->transactionNumber; + + // then do a comparison + if(!( *l == *r)) { + grpMatch = false; + break; + } + + // now do a comparison of grp meta types + + if(grpMetaR.find(grpId) == grpMetaR.end()) + { + grpMetaMatch = false; + break; + } + + RsGxsGrpMetaData *l_Meta = mit->second, + *r_Meta = grpMetaR[grpId]; + + if(!(*l_Meta == *r_Meta)) + { + grpMetaMatch = false; + break; + } + + /* release resources */ + delete l_Meta; + delete r_Meta; + delete l; + delete r; + + remove(grpId.toStdString().c_str()); + } + + grpMetaR.clear(); + + EXPECT_TRUE(grpMatch); + tearDown(); +} + +/*! + * Test for both selective and + * bulk msg retrieval + */ +void test_messageStoresAndRetrieve() +{ + setUp(); + + // first create a grpId + RsGxsGroupId grpId0, grpId1; + + grpId0.random(); + grpId1.random(); + std::vector grpV; // stores grpIds of all msgs stored and retrieved + grpV.push_back(grpId0); + grpV.push_back(grpId1); + + std::map msgs; + std::map msgs_copy; + RsNxsMsg* msg = NULL; + RsGxsMsgMetaData* msgMeta = NULL; + int nMsgs = rand()%120; + GxsMsgReq req; + + std::map VergrpId0, VergrpId1; + std::map VerMetagrpId0, VerMetagrpId1; + + for(int i=0; i p(msg, msgMeta); + int chosen = 0; + if(rand()%50 > 24){ + chosen = 1; + + } + + const RsGxsGroupId& grpId = grpV[chosen]; + + if(chosen) + req[grpId].push_back(msg->msgId); + + msgMeta->mMsgId = msg->msgId; + msgMeta->mGroupId = msg->grpId = grpId; + + RsNxsMsg* msg_copy = new RsNxsMsg(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + RsGxsMsgMetaData* msgMeta_copy = new RsGxsMsgMetaData(); + + *msg_copy = *msg; + *msgMeta_copy = *msgMeta; + + // store msgs in map to use for verification + std::pair vP(msg->msgId, msg_copy); + std::pair vPmeta(msg->msgId, msgMeta_copy); + + if(!chosen) + { + VergrpId0.insert(vP); + VerMetagrpId0.insert(vPmeta); + } + else + { + VergrpId1.insert(vP); + VerMetagrpId0.insert(vPmeta); + } + + + + msg = NULL; + msgMeta = NULL; + + msgs.insert(p); + msgs_copy.insert(std::make_pair(msg_copy, msgMeta_copy)); + } + + req[grpV[0]] = std::vector(); // assign empty list for other + + dStore->storeMessage(msgs); + msgs.clear(); + msgs = msgs_copy; + + // now retrieve msgs for comparison + // first selective retrieval + + GxsMsgResult msgResult; + GxsMsgMetaResult msgMetaResult; + dStore->retrieveNxsMsgs(req, msgResult, false); + + dStore->retrieveGxsMsgMetaData(req, msgMetaResult); + + // now look at result for grpId 1 + std::vector& result0 = msgResult[grpId0]; + std::vector& result1 = msgResult[grpId1]; + std::vector& resultMeta0 = msgMetaResult[grpId0]; + std::vector& resultMeta1 = msgMetaResult[grpId1]; + + + + bool msgGrpId0_Match = true, msgGrpId1_Match = true; + bool msgMetaGrpId0_Match = true, msgMetaGrpId1_Match = true; + + // MSG test, selective retrieval + for(std::vector::size_type i = 0; i < result0.size(); i++) + { + RsNxsMsg* l = result0[i] ; + + if(VergrpId0.find(l->msgId) == VergrpId0.end()) + { + msgGrpId0_Match = false; + break; + } + + RsNxsMsg* r = VergrpId0[l->msgId]; + r->transactionNumber = l->transactionNumber; + + if(!(*l == *r)) + { + msgGrpId0_Match = false; + break; + } + } + + EXPECT_TRUE(msgGrpId0_Match); + + // META test + for(std::vector::size_type i = 0; i < resultMeta0.size(); i++) + { + RsGxsMsgMetaData* l = resultMeta0[i] ; + + if(VerMetagrpId0.find(l->mMsgId) == VerMetagrpId0.end()) + { + msgMetaGrpId0_Match = false; + break; + } + + RsGxsMsgMetaData* r = VerMetagrpId0[l->mMsgId]; + + if(!(*l == *r)) + { + msgMetaGrpId0_Match = false; + break; + } + } + + EXPECT_TRUE(msgMetaGrpId0_Match); + + // MSG test, bulk retrieval + for(std::vector::size_type i = 0; i < result1.size(); i++) + { + RsNxsMsg* l = result1[i] ; + + if(VergrpId1.find(l->msgId) == VergrpId1.end()) + { + msgGrpId1_Match = false; + break; + } + + RsNxsMsg* r = VergrpId1[l->msgId]; + + r->transactionNumber = l->transactionNumber; + + if(!(*l == *r)) + { + msgGrpId1_Match = false; + break; + } + } + + EXPECT_TRUE(msgGrpId1_Match); + + //dStore->retrieveGxsMsgMetaData(); + std::string msgFile = grpId0.toStdString() + "-msgs"; + remove(msgFile.c_str()); + msgFile = grpId1.toStdString() + "-msgs"; + remove(msgFile.c_str()); + tearDown(); +} + + + +void setUp(){ + dStore = new RsDataService(".", DATA_BASE_NAME, RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +void tearDown(){ + + dStore->resetDataStore(); // reset to clean up store files except db + delete dStore; + dStore = NULL; + int rc = remove(DATA_BASE_NAME); + + if(rc == 0){ + std::cerr << "Successful tear down" << std::endl; + } + else{ + std::cerr << "Tear down failed" << std::endl; + perror("Error: "); + } + +} + + diff --git a/tests/unittests/libretroshare/gxs/data_service/rsdataservice_test.h b/tests/unittests/libretroshare/gxs/data_service/rsdataservice_test.h new file mode 100644 index 000000000..89d4a4f5c --- /dev/null +++ b/tests/unittests/libretroshare/gxs/data_service/rsdataservice_test.h @@ -0,0 +1,33 @@ +#ifndef RSDATASERVICE_TEST_H +#define RSDATASERVICE_TEST_H + +#include "util/rsthreads.h" +#include "serialiser/rsnxsitems.h" +#include "gxs/rsgds.h" + +void test_messageStoresAndRetrieve(); + +void test_groupStoreAndRetrieve(); + +void test_storeAndDeleteGroup(); +void test_storeAndDeleteMessage(); + +void test_searchMsg(); +void test_searchGrp(); + +bool operator ==(const RsGxsGrpMetaData& l, const RsGxsGrpMetaData& r); +bool operator ==(const RsGxsMsgMetaData& l, const RsGxsMsgMetaData& r); + +void test_multiThreaded(); + +class DataReadWrite : RsThread +{ + + + +}; + +void test_cacheSize(); + + +#endif // RSDATASERVICE_TEST_H diff --git a/tests/unittests/libretroshare/gxs/data_service/rsgxsdata_test.cc b/tests/unittests/libretroshare/gxs/data_service/rsgxsdata_test.cc new file mode 100644 index 000000000..8641fffa7 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/data_service/rsgxsdata_test.cc @@ -0,0 +1,41 @@ + +#include + +#include "libretroshare/serialiser/support.h" +#include "libretroshare/gxs/common/data_support.h" +#include "gxs/rsgxsdata.h" + +TEST(libretroshare_gxs, RsGxsData) +{ + + RsGxsGrpMetaData grpMeta1, grpMeta2; + RsGxsMsgMetaData msgMeta1, msgMeta2; + + grpMeta1.clear(); + init_item(&grpMeta1); + + msgMeta1.clear(); + init_item(&msgMeta1); + + uint32_t pktsize = grpMeta1.serial_size(); + char grp_data[pktsize]; + + bool ok = true; + + ok &= grpMeta1.serialise(grp_data, pktsize); + grpMeta2.clear(); + ok &= grpMeta2.deserialise(grp_data, pktsize); + + EXPECT_TRUE(grpMeta1 == grpMeta2); + + pktsize = msgMeta1.serial_size(); + char msg_data[pktsize]; + + ok &= msgMeta1.serialise(msg_data, &pktsize); + msgMeta2.clear(); + ok &= msgMeta2.deserialise(msg_data, &pktsize); + + EXPECT_TRUE(msgMeta1 == msgMeta2); +} + + diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/genexchange_test.pro b/tests/unittests/libretroshare/gxs/gen_exchange/genexchange_test.pro new file mode 100644 index 000000000..aa67a28ed --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/genexchange_test.pro @@ -0,0 +1,180 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2012-05-06T09:19:26 +# +#------------------------------------------------- + + +# +QT += core network + +QT -= gui + +CONFIG += gen_exchange_target + + +CONFIG += bitdht + + + +TARGET = gen_exchange_test + +CONFIG += console +CONFIG -= app_bundle + +TEMPLATE = app + +CONFIG += debug + +debug { +# DEFINES *= DEBUG +# DEFINES *= OPENDHT_DEBUG DHT_DEBUG CONN_DEBUG DEBUG_UDP_SORTER P3DISC_DEBUG DEBUG_UDP_LAYER FT_DEBUG EXTADDRSEARCH_DEBUG +# DEFINES *= CONTROL_DEBUG FT_DEBUG DEBUG_FTCHUNK P3TURTLE_DEBUG +# DEFINES *= P3TURTLE_DEBUG +# DEFINES *= NET_DEBUG +# DEFINES *= DISTRIB_DEBUG +# DEFINES *= P3TURTLE_DEBUG FT_DEBUG DEBUG_FTCHUNK MPLEX_DEBUG +# DEFINES *= STATUS_DEBUG SERV_DEBUG RSSERIAL_DEBUG #CONN_DEBUG + + QMAKE_CXXFLAGS -= -O2 -fomit-frame-pointer + QMAKE_CXXFLAGS *= -g -fno-omit-frame-pointer +} +################################# Linux ########################################## +# Put lib dir in QMAKE_LFLAGS so it appears before -L/usr/lib +linux-* { + #CONFIG += version_detail_bash_script + QMAKE_CXXFLAGS *= -D_FILE_OFFSET_BITS=64 + + system(which gpgme-config >/dev/null 2>&1) { + INCLUDEPATH += $$system(gpgme-config --cflags | sed -e "s/-I//g") + } else { + message(Could not find gpgme-config on your system, assuming gpgme.h is in /usr/include) + } + + PRE_TARGETDEPS *= ../../../lib/libretroshare.a + + LIBS += ../../../lib/libretroshare.a + LIBS += ../../../../../libbitdht/src/lib/libbitdht.a + LIBS += ../../../../../openpgpsdk/src/lib/libops.a + LIBS += -lssl -lgpgme -lupnp -lixml -lgnome-keyring -lbz2 + # We need a explicit path here, to force using the home version of sqlite3 that really encrypts the database. + LIBS += /home/crispy/Development/retroshare/sqlcipher/sqlcipher/.libs/libsqlite3.a + LIBS *= -rdynamic -frtti + DEFINES *= HAVE_XSS # for idle time, libx screensaver extensions + DEFINES *= UBUNTU +} + +linux-g++ { + OBJECTS_DIR = temp/linux-g++/obj +} + +linux-g++-64 { + OBJECTS_DIR = temp/linux-g++-64/obj +} + +#################################### Windows ##################################### + +win32 { + + DEFINES *= WINDOWS_SYS \ + WIN32 \ + STATICLIB \ + MINGW + # Switch on extra warnings + QMAKE_CFLAGS += -Wextra + QMAKE_CXXFLAGS += -Wextra + + # Switch off optimization for release version + QMAKE_CXXFLAGS_RELEASE -= -O2 + QMAKE_CXXFLAGS_RELEASE += -O0 + QMAKE_CFLAGS_RELEASE -= -O2 + QMAKE_CFLAGS_RELEASE += -O0 + + # Switch on optimization for debug version + #QMAKE_CXXFLAGS_DEBUG += -O2 + #QMAKE_CFLAGS_DEBUG += -O2 + +# PRE_TARGETDEPS += ../../libretroshare/src/lib/libretroshare.a + PRE_TARGETDEPS += ../../../../../libretroshare/libretroshare-build-desktop/lib/libretroshare.a + + LIBS += ../../../../../libretroshare/libretroshare-build-desktop/lib/libretroshare.a + LIBS += C:\Development\Rs\v0.5-gxs-b1\openpgpsdk\openpgpsdk-build-desktop\lib\libops.a + LIBS += C:\Development\Libraries\sqlite\sqlite-autoconf-3070900\lib\libsqlite3.a + LIBS += -L"../../../../../lib" + LIBS += -lssl -lcrypto -lgpgme -lpthreadGC2d -lminiupnpc -lz -lbz2 +# added after bitdht +# LIBS += -lws2_32 + LIBS += -luuid -lole32 -liphlpapi -lcrypt32-cygwin -lgdi32 + LIBS += -lole32 -lwinmm + + # export symbols for the plugins + #LIBS += -Wl,--export-all-symbols,--out-implib,lib/libretroshare-gui.a + + GPG_ERROR_DIR = ../../../../libgpg-error-1.7 + GPGME_DIR = ../../../../gpgme-1.1.8 + GPG_ERROR_DIR = ../../../../lib/libgpg-error-1.7 + GPGME_DIR = ../../../../lib/gpgme-1.1.8 + SSL_DIR = ../../../../../OpenSSL + OPENPGPSDK_DIR = ../../../../openpgpsdk/src + INCLUDEPATH += . $${SSL_DIR}/include $${GPGME_DIR}/src $${GPG_ERROR_DIR}/src \ + $${OPENPGPSDK_DIR} + + SQLITE_DIR = ../../../../../../Libraries/sqlite/sqlite-autoconf-3070900 + INCLUDEPATH += . \ + $${SQLITE_DIR} + + + + +} + +bitdht { + + # Chris version. + #LIBS += ../../libbitdht/libbitdht-build-desktop/lib/libbitdht.a + #PRE_TARGETDEPS *= ../../libbitdht/libbitdht-build-desktop/lib/libbitdht.a +} + +win32 { +# must be added after bitdht + LIBS += -lws2_32 +} + +version_detail_bash_script { + DEFINES += ADD_LIBRETROSHARE_VERSION_INFO + QMAKE_EXTRA_TARGETS += write_version_detail + PRE_TARGETDEPS = write_version_detail + write_version_detail.commands = ./version_detail.sh +} + +install_rs { + INSTALLS += binary_rs + binary_rs.path = $$(PREFIX)/usr/bin + binary_rs.files = ./RetroShare +} + + +gen_exchange_target { + + SOURCES += \ + ../common/support.cc \ + genexchangetester.cpp \ + genexchangetestservice.cpp \ + rsdummyservices.cc \ + gxspublishgrouptest.cc \ + gxspublishmsgtest.cc \ + rsgenexchange_test.cc + + HEADERS += ../common/support.h \ + ../data_service/rsdataservice_test.h \ + gxspublishgrouptest.h \ + gxspublishmsgtest.h \ + rsdummyservices.h \ + ../common/data_support.h \ + ../common/support.h + +} + + +INCLUDEPATH += ../../../ +INCLUDEPATH += ../common diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetester.cc b/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetester.cc new file mode 100644 index 000000000..8cc8fc280 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetester.cc @@ -0,0 +1,592 @@ + + + +#include "genexchangetester.h" +#include "libretroshare/serialiser/support.h" +#include "gxs/rsdataservice.h" +#include "retroshare/rsgxsflags.h" + + +GenExchangeTest::GenExchangeTest(GenExchangeTestService* const mTestService, RsGeneralDataService* dataService, int pollingTO) + : mDataService(dataService), mTestService(mTestService), mTokenService(mTestService->getTokenService()), + mPollingTO(pollingTO) +{ +} + +GenExchangeTest::~GenExchangeTest() +{ +} + + +void GenExchangeTest::pollForToken(uint32_t token, const RsTokReqOptions &opts, bool fill) +{ + double timeDelta = 0.2; + time_t now = time(NULL); + time_t stopw = now + mPollingTO; + + while(now < stopw) + { +#ifndef WINDOWS_SYS + usleep((int) (timeDelta * 1000000)); +#else + Sleep((int) (timeDelta * 1000)); +#endif + + if((RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE == mTokenService->requestStatus(token))) + { + switch(opts.mReqType) + { + case GXS_REQUEST_TYPE_GROUP_DATA: + if(fill) + mTestService->getGroupDataTS(token, mGrpDataIn); + break; + case GXS_REQUEST_TYPE_GROUP_META: + if(fill) + mTestService->getGroupMetaTS(token, mGrpMetaDataIn); + break; + case GXS_REQUEST_TYPE_GROUP_IDS: + if(fill) + mTestService->getGroupListTS(token, mGrpIdsIn); + break; + case GXS_REQUEST_TYPE_MSG_DATA: + if(fill) + mTestService->getMsgDataTS(token, mMsgDataIn); + break; + case GXS_REQUEST_TYPE_MSG_META: + if(fill) + mTestService->getMsgMetaTS(token, mMsgMetaDataIn); + break; + case GXS_REQUEST_TYPE_MSG_IDS: + if(fill) + mTestService->getMsgListTS(token, mMsgIdsIn); + break; + case GXS_REQUEST_TYPE_MSG_RELATED_IDS: + if(fill) + mTestService->getMsgRelatedListTS(token, mMsgRelatedIdsIn); + break; + case GXS_REQUEST_TYPE_MSG_RELATED_DATA: + if(fill) + mTestService->getMsgRelatedDataTS(token, mMsgRelatedDataMapIn); + break; + } + break; + } + else if(RsTokenService::GXS_REQUEST_V2_STATUS_FAILED == mTokenService->requestStatus(token)) + { + mTokenService->cancelRequest(token); + break; + } + now = time(NULL); + } +} + + + +bool GenExchangeTest::pollForMsgAcknowledgement(uint32_t token, + RsGxsGrpMsgIdPair& msgId) +{ + double timeDelta = 0.2; + + time_t now = time(NULL); + time_t stopw = now + mPollingTO; + + while(now < stopw) + { +#ifndef WINDOWS_SYS + usleep((int) (timeDelta * 1000000)); +#else + Sleep((int) (timeDelta * 1000)); +#endif + + if((RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE == mTokenService->requestStatus(token))) + { + mTestService->acknowledgeTokenMsg(token, msgId); + return true; + } + else if(RsTokenService::GXS_REQUEST_V2_STATUS_FAILED == mTokenService->requestStatus(token)) + { + mTokenService->cancelRequest(token); + return false; + } + now = time(NULL); + } + return false; +} + +GenExchangeTestService* GenExchangeTest::getTestService() +{ + return mTestService; +} + +RsTokenService* GenExchangeTest::getTokenService() +{ + return mTokenService; +} +bool GenExchangeTest::pollForGrpAcknowledgement(uint32_t token, + RsGxsGroupId& grpId) +{ + double timeDelta = 0.2; + time_t now = time(NULL); + time_t stopw = now + mPollingTO; + while(now < stopw) + { +#ifndef WINDOWS_SYS + usleep((int) (timeDelta * 1000000)); +#else + Sleep((int) (timeDelta * 1000)); +#endif + + if((RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE == mTokenService->requestStatus(token))) + { + mTestService->acknowledgeTokenGrp(token, grpId); + return true; + } + else if(RsTokenService::GXS_REQUEST_V2_STATUS_FAILED == mTokenService->requestStatus(token)) + { + mTokenService->cancelRequest(token); + return false; + } + now = time(NULL); + } + return false; +} + +void GenExchangeTest::setUp() +{ + mDataService->resetDataStore(); + + // would be useful for genexchange services + // to have a protected reset button + mTestService->start(); +} + +void GenExchangeTest::breakDown() +{ + mDataService->resetDataStore(); + mTestService->join(); + clearAllData(); +} + +bool msgDataSort(const RsDummyMsg* m1, const RsDummyMsg* m2) +{ + return m1->meta.mMsgId < m2->meta.mMsgId; +} + +bool GenExchangeTest::compareMsgDataMaps() +{ + DummyMsgMap::iterator mit = mMsgDataOut.begin(); + + bool ok = true; + for(; mit != mMsgDataOut.end(); mit++) + { + const RsGxsGroupId& grpId = mit->first; + std::vector& v1 = mit->second, + &v2 = mMsgDataIn[grpId]; + + if(v1.size() != v2.size()) + return false; + + std::sort(v1.begin(), v1.end(), msgDataSort); + std::sort(v2.begin(), v2.end(), msgDataSort); + + ok &= Comparison, RsDummyMsg*>::comparison(v1, v2); + } + + return ok; +} + + +bool GenExchangeTest::compareMsgIdMaps() +{ + GxsMsgIdResult::const_iterator mit = mMsgIdsOut.begin(); + bool ok = true; + for(; mit != mMsgIdsOut.end(); mit++) + { + const RsGxsGroupId& grpId = mit->first; + const std::vector& v1 = mit->second, + &v2 = mMsgIdsIn[grpId]; + + ok &= Comparison, RsGxsMessageId>::comparison(v1, v2); + } + return ok; +} + + +bool GenExchangeTest::compareMsgMetaMaps() +{ + GxsMsgMetaMap::iterator mit = mMsgMetaDataOut.begin(); + bool ok = true; + for(; mit != mMsgMetaDataOut.end(); mit++) + { + const RsGxsGroupId& grpId = mit->first; + const std::vector& v1 = mit->second, + &v2 = mMsgMetaDataOut[grpId]; + ok &= Comparison, RsMsgMetaData>::comparison(v1, v2); + } + return ok; +} + + +bool GenExchangeTest::compareMsgRelateIdsMap() +{ + return false; +} + + +bool GenExchangeTest::compareMsgRelatedDataMap() +{ + return false; +} + +bool grpDataSort(const RsDummyGrp* g1, const RsDummyGrp* g2) +{ + return g1->meta.mGroupId < g2->meta.mGroupId; +} + +bool GenExchangeTest::compareGrpData() +{ + + std::sort(mGrpDataIn.begin(), mGrpDataIn.end(), grpDataSort); + std::sort(mGrpDataOut.begin(), mGrpDataOut.end(), grpDataSort); + bool ok = Comparison, RsDummyGrp*>::comparison + (mGrpDataIn, mGrpDataOut); + return ok; +} + +bool operator<(const RsGroupMetaData& l, const RsGroupMetaData& r) +{ + return l.mGroupId < r.mGroupId; +} + +bool GenExchangeTest::compareGrpMeta() +{ + + mGrpMetaDataIn.sort(); + mGrpMetaDataOut.sort(); + + bool ok = Comparison, RsGroupMetaData>::comparison + (mGrpMetaDataIn, mGrpMetaDataOut); + return ok; +} + + +bool GenExchangeTest::compareGrpIds() +{ + mGrpIdsIn.sort(); + mGrpIdsOut.sort(); + bool ok = Comparison, RsGxsGroupId>::comparison + (mGrpIdsIn, mGrpIdsOut); + return ok; +} + +void GenExchangeTest::createGrps(uint32_t nGrps, + std::list& groupId) +{ + // create n groups and publish all nGrps and collect id information + for(uint32_t i=0; i < nGrps; i++) + { + RsDummyGrp* grp = new RsDummyGrp(); + init(*grp); + uint32_t token; + mTestService->publishDummyGrp(token, grp); + RsGxsGroupId grpId; + pollForGrpAcknowledgement(token, grpId); + groupId.push_back(grpId); + } +} + +void GenExchangeTest::init(RsMsgMetaData& msgMetaData) const +{ + //randString(SHORT_STR, msgMeta.mAuthorId); + randString(SHORT_STR, msgMetaData.mMsgName); + randString(SHORT_STR, msgMetaData.mServiceString); + msgMetaData.mOrigMsgId.random(); + msgMetaData.mParentId.random(); + msgMetaData.mThreadId.random(); + msgMetaData.mGroupId.random(); + + msgMetaData.mChildTs = randNum(); + msgMetaData.mMsgStatus = randNum(); + msgMetaData.mMsgFlags = randNum(); + msgMetaData.mPublishTs = randNum(); +} + +uint32_t GenExchangeTest::randNum() const +{ + return rand()%23562424; +} + +void GenExchangeTest::init(RsGroupMetaData& grpMetaData) const +{ + grpMetaData.mGroupId.random(); + //randString(SHORT_STR, grpMetaData.mAuthorId); + randString(SHORT_STR, grpMetaData.mGroupName); + randString(SHORT_STR, grpMetaData.mServiceString); + + + grpMetaData.mGroupFlags = randNum(); + grpMetaData.mLastPost = randNum(); + grpMetaData.mGroupStatus = randNum(); + grpMetaData.mMsgCount = randNum(); + grpMetaData.mPop = randNum(); + grpMetaData.mSignFlags = randNum(); + grpMetaData.mPublishTs = randNum(); + grpMetaData.mSubscribeFlags = GXS_SERV::GROUP_SUBSCRIBE_ADMIN; +} + +void GenExchangeTest::init(RsDummyGrp& grpItem) const +{ + randString(SHORT_STR, grpItem.grpData); + init(grpItem.meta); +} + + +void GenExchangeTest::init(RsDummyMsg& msgItem) const +{ + randString(SHORT_STR, msgItem.msgData); + init(msgItem.meta); +} + +void GenExchangeTest::storeToMsgDataOutMaps(const DummyMsgMap& msgDataOut) +{ + mMsgDataOut.insert(msgDataOut.begin(), msgDataOut.end()); +} + + +void GenExchangeTest::storeToMsgIdsOutMaps(const GxsMsgIdResult& msgIdsOut) +{ + mMsgIdsOut.insert(msgIdsOut.begin(), msgIdsOut.end()); +} + + +void GenExchangeTest::storeToMsgMetaOutMaps(const GxsMsgMetaMap& msgMetaOut) +{ + mMsgMetaDataOut.insert(msgMetaOut.begin(), msgMetaOut.end()); +} + + +void GenExchangeTest::storeToMsgDataInMaps(const DummyMsgMap& msgDataIn) +{ + mMsgDataIn.insert(msgDataIn.begin(), msgDataIn.end()); +} + + +void GenExchangeTest::storeToMsgIdsInMaps(const GxsMsgIdResult& msgIdsIn) +{ + mMsgIdsIn.insert(msgIdsIn.begin(), msgIdsIn.end()); +} + + +void GenExchangeTest::storeToMsgMetaInMaps(const GxsMsgMetaMap& msgMetaIn) +{ + mMsgMetaDataIn.insert(msgMetaIn.begin(), msgMetaIn.end()); +} + + +void GenExchangeTest::storeToGrpIdsOutList( + const std::list& grpIdOut) +{ + mGrpIdsOut.insert(mGrpIdsOut.end(), grpIdOut.begin(), grpIdOut.end()); +} + + +void GenExchangeTest::storeToGrpMetaOutList( + const std::list& grpMetaOut) +{ + mGrpMetaDataOut.insert(mGrpMetaDataOut.end(), grpMetaOut.begin(), grpMetaOut.end()); +} + + +void GenExchangeTest::storeToGrpDataOutList( + const std::vector& grpDataOut) +{ + mGrpDataOut.insert(mGrpDataOut.end(), grpDataOut.begin(), grpDataOut.end()); +} + + +void GenExchangeTest::storeToGrpIdsInList( + const std::list& grpIdIn) +{ + mGrpIdsIn.insert(mGrpIdsIn.end(), grpIdIn.begin(), grpIdIn.end()); +} + + +void GenExchangeTest::storeToGrpMetaInList( + const std::list& grpMetaIn) +{ + mGrpMetaDataIn.insert(mGrpMetaDataIn.end(), grpMetaIn.begin(), grpMetaIn.end()); +} + + +void GenExchangeTest::storeToGrpDataInList( + const std::vector& grpDataIn) +{ + mGrpDataIn.insert(mGrpDataIn.begin(), grpDataIn.begin(), grpDataIn.end()); +} +void GenExchangeTest::clearAllData() +{ + clearMsgDataInMap(); + clearMsgDataOutMap(); + clearMsgIdInMap(); + clearMsgIdOutMap(); + clearMsgMetaInMap(); + clearMsgMetaOutMap(); + clearGrpDataInList(); + clearGrpDataOutList(); + clearGrpMetaInList(); + clearGrpMetaOutList(); + clearGrpIdInList(); + clearGrpIdOutList(); +} +void GenExchangeTest::clearMsgDataInMap() +{ + mMsgDataIn.clear(); +} + + +void GenExchangeTest::clearMsgDataOutMap() +{ + + clearMsgDataMap(mMsgDataOut); +} + +void GenExchangeTest::clearMsgDataMap(DummyMsgMap& msgDataMap) const +{ + DummyMsgMap::iterator it = msgDataMap.begin(); + + for(; it != msgDataMap.end(); it++) + { + deleteResVector(it->second); + } +} + +void GenExchangeTest::clearMsgMetaInMap() +{ + mMsgMetaDataIn.clear(); +} + + +void GenExchangeTest::clearMsgMetaOutMap() +{ + mMsgMetaDataOut.clear(); +} + + +void GenExchangeTest::clearMsgIdInMap() +{ + mMsgIdsIn.clear(); +} + + +void GenExchangeTest::clearMsgIdOutMap() +{ + mMsgIdsOut.clear(); +} + + +void GenExchangeTest::clearMsgRelatedIdInMap() +{ + mMsgRelatedIdsIn.clear(); +} + + +void GenExchangeTest::clearGrpDataInList() +{ + clearGrpDataList(mGrpDataIn); +} + +void GenExchangeTest::clearGrpDataList(std::vector& grpData) const +{ + deleteResVector(grpData); +} + + +void GenExchangeTest::clearGrpDataOutList() +{ + clearGrpDataList(mGrpDataOut); +} + + +void GenExchangeTest::clearGrpMetaInList() +{ + mGrpMetaDataIn.clear(); +} + + +void GenExchangeTest::clearGrpMetaOutList() +{ + mGrpMetaDataOut.clear(); +} + + +void GenExchangeTest::clearGrpIdInList() +{ + mGrpIdsIn.clear(); +} + + +void GenExchangeTest::clearGrpIdOutList() +{ + mGrpIdsOut.clear(); +} + + +bool operator ==(const RsMsgMetaData& lMeta, const RsMsgMetaData& rMeta) +{ + + if(lMeta.mAuthorId != rMeta.mAuthorId) return false; + if(lMeta.mChildTs != rMeta.mChildTs) return false; + if(lMeta.mGroupId != rMeta.mGroupId) return false; + if(lMeta.mMsgFlags != rMeta.mMsgFlags) return false; + if(lMeta.mMsgId != rMeta.mMsgId) return false; + if(lMeta.mMsgName != rMeta.mMsgName) return false; + //if(lMeta.mMsgStatus != rMeta.mMsgStatus) return false; + if(lMeta.mOrigMsgId != rMeta.mOrigMsgId) return false; + if(lMeta.mParentId != rMeta.mParentId) return false; + //if(lMeta.mPublishTs != rMeta.mPublishTs) return false; // don't compare this as internally set in gxs + if(lMeta.mThreadId != rMeta.mThreadId) return false; + if(lMeta.mServiceString != rMeta.mServiceString) return false; + + return true; +} + +bool operator ==(const RsGroupMetaData& lMeta, const RsGroupMetaData& rMeta) +{ + if(lMeta.mAuthorId != rMeta.mAuthorId) return false; + if(lMeta.mGroupFlags != rMeta.mGroupFlags) return false; + if(lMeta.mGroupId != rMeta.mGroupId) return false; + if(lMeta.mGroupName != rMeta.mGroupName) return false; + if(lMeta.mGroupStatus != rMeta.mGroupStatus) return false; + if(lMeta.mLastPost != rMeta.mLastPost) return false; + if(lMeta.mMsgCount != rMeta.mMsgCount) return false; + if(lMeta.mPop != rMeta.mPop) return false; + // if(lMeta.mPublishTs != rMeta.mPublishTs) return false; set in gxs + if(lMeta.mServiceString != rMeta.mServiceString) return false; + if(lMeta.mSignFlags != rMeta.mSignFlags) return false; + // if(lMeta.mSubscribeFlags != rMeta.mSubscribeFlags) return false; + + return true; +} + +bool operator ==(const RsDummyGrp& lGrp, const RsDummyGrp& rGrp) +{ + + if(lGrp.grpData != rGrp.grpData) return false; + if(! (lGrp.meta == rGrp.meta)) return false; + + return true; +} + +bool operator ==(const RsDummyMsg& lMsg, const RsDummyMsg& rMsg) +{ + if(lMsg.msgData != rMsg.msgData) return false; + if(!(lMsg.meta == rMsg.meta)) return false; + + return true; +} + +bool operator ==(const RsGxsGrpItem& lGrp, const RsGxsGrpItem& rGrp) +{ + return false; +} + diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetester.h b/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetester.h new file mode 100644 index 000000000..13bb1cf6e --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetester.h @@ -0,0 +1,278 @@ +#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: + + /*! + * 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 + void deleteResVector(std::vector& v) const + { + typename std::vector::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 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 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; + } + }; + + // 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& grpIdOut); + void storeToGrpMetaOutList(const std::list& grpMetaOut); + void storeToGrpDataOutList(const std::vector& grpDataOut); + + void storeToGrpIdsInList(const std::list& grpIdIn); + void storeToGrpMetaInList(const std::list& grpMetaOut); + void storeToGrpDataInList(const std::vector& 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& 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& groupId); + + /*! + * @return random number + */ + uint32_t randNum() const; + +private: + + std::vector mGrpDataOut, mGrpDataIn; + std::list mGrpMetaDataOut, mGrpMetaDataIn; + std::list mGrpIdsOut, mGrpIdsIn; + + std::map > mMsgDataOut, mMsgDataIn; + GxsMsgMetaMap mMsgMetaDataOut, mMsgMetaDataIn; + GxsMsgIdResult mMsgIdsOut, mMsgIdsIn; + + MsgRelatedIdResult mMsgRelatedIdsOut, mMsgRelatedIdsIn; + GxsMsgRelatedDataMap mMsgRelatedDataMapOut, mMsgRelatedDataMapIn; + + std::vector mRandGrpIds; // ids that exist to help group testing + +private: + + RsGeneralDataService* mDataService; + GenExchangeTestService* mTestService; + RsTokenService* mTokenService; + int mPollingTO; +}; + +#endif // GENEXCHANGETESTER_H diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetestservice.cc b/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetestservice.cc new file mode 100644 index 000000000..be4b61261 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetestservice.cc @@ -0,0 +1,105 @@ +#include "genexchangetestservice.h" + +GenExchangeTestService::GenExchangeTestService(RsGeneralDataService *dataServ, RsNetworkExchangeService * netService, + RsGixs* gixs) + : RsGenExchange(dataServ, netService, new RsDummySerialiser(), RS_SERVICE_TYPE_DUMMY, gixs, 0) +{ + +} + +RsServiceInfo GenExchangeTestService::getServiceInfo() +{ + RsServiceInfo info; + return info; +} + +void GenExchangeTestService::notifyChanges(std::vector &changes) +{ + return; +} + +void GenExchangeTestService::publishDummyGrp(uint32_t &token, RsDummyGrp *grp) +{ + publishGroup(token, grp); +} + +void GenExchangeTestService::updateDummyGrp(uint32_t &token, RsGxsGroupUpdateMeta &updateMeta, RsDummyGrp *group) +{ + //updateGroup(token, updateMeta, group); + updateGroup(token, group); +} + +void GenExchangeTestService::publishDummyMsg(uint32_t &token, RsDummyMsg *msg) +{ + publishMsg(token, msg); +} + +bool GenExchangeTestService::getGroupListTS(const uint32_t &token, std::list &groupIds) +{ + return getGroupList(token, groupIds); +} + +bool GenExchangeTestService::getGroupMetaTS(const uint32_t &token, std::list &groupInfo) +{ + return getGroupMeta(token, groupInfo); +} + +bool GenExchangeTestService::getGroupDataTS(const uint32_t &token, std::vector& grpItem) +{ + return getGroupDataT(token, grpItem); +} + +bool GenExchangeTestService::getMsgDataTS(const uint32_t &token, DummyMsgMap &msgItems) +{ + return getMsgDataT(token, msgItems); +} + +bool GenExchangeTestService::getMsgRelatedDataTS(const uint32_t &token, GxsMsgRelatedDataMap &msgItems) +{ + return getMsgRelatedData(token, msgItems); +} + +bool GenExchangeTestService::getMsgMetaTS(const uint32_t &token, GxsMsgMetaMap &msgInfo) +{ + return getMsgMeta(token, msgInfo); +} + +bool GenExchangeTestService::getMsgListTS(const uint32_t &token, GxsMsgIdResult &msgIds) +{ + return getMsgList(token, msgIds); +} + +bool GenExchangeTestService::getMsgRelatedListTS(const uint32_t &token, MsgRelatedIdResult &msgIds) +{ + return getMsgRelatedList(token, msgIds); +} + +void GenExchangeTestService::setGroupServiceStringTS(uint32_t &token, const RsGxsGroupId &grpId, const std::string &servString) +{ + RsGenExchange::setGroupServiceString(token, grpId, servString); +} + +void GenExchangeTestService::setGroupStatusFlagTS(uint32_t &token, const RsGxsGroupId &grpId, const uint32_t &status, const uint32_t& mask) +{ + RsGenExchange::setGroupStatusFlags(token, grpId, status, mask); +} + +void GenExchangeTestService::setGroupSubscribeFlagTS(uint32_t &token, const RsGxsGroupId &grpId, const uint32_t &status, const uint32_t& mask) +{ + RsGenExchange::setGroupSubscribeFlags(token, grpId, status, mask); +} + +void GenExchangeTestService::setMsgServiceStringTS(uint32_t &token, const RsGxsGrpMsgIdPair &msgId, const std::string &servString) +{ + RsGenExchange::setMsgServiceString(token, msgId, servString); +} + +void GenExchangeTestService::setMsgStatusFlagTS(uint32_t &token, const RsGxsGrpMsgIdPair &msgId, const uint32_t &status, const uint32_t& mask) +{ + RsGenExchange::setMsgStatusFlags(token, msgId, status, mask); +} + +void GenExchangeTestService::service_tick() +{ + +} diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetestservice.h b/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetestservice.h new file mode 100644 index 000000000..d148c0178 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/genexchangetestservice.h @@ -0,0 +1,99 @@ +#ifndef GENEXCHANGETESTSERVICE_H +#define GENEXCHANGETESTSERVICE_H + +#include "gxs/rsgenexchange.h" +#include "retroshare/rsgxsifacehelper.h" +#include "rsdummyservices.h" + +typedef std::map > DummyMsgMap; + +class GenExchangeTestService : public RsGenExchange +{ +public: + GenExchangeTestService(RsGeneralDataService* dataServ, RsNetworkExchangeService* nxs, RsGixs* gixs); + + void notifyChanges(std::vector& changes); + + void publishDummyGrp(uint32_t& token, RsDummyGrp* grp); + void updateDummyGrp(uint32_t &token, RsGxsGroupUpdateMeta& meta, RsDummyGrp *group); + void publishDummyMsg(uint32_t& token, RsDummyMsg* msg); + + RsServiceInfo getServiceInfo(); + + /*! + * Retrieve group list for a given token + * @param token + * @param groupIds + * @return false if token cannot be redeemed, if false you may have tried to redeem when not ready + */ + bool getGroupListTS(const uint32_t &token, std::list &groupIds); + + /*! + * Retrieve msg list for a given token sectioned by group Ids + * @param token token to be redeemed + * @param msgIds a map of grpId -> msgList (vector) + */ + bool getMsgListTS(const uint32_t &token, GxsMsgIdResult &msgIds); + + + /*! + * retrieve group meta data associated to a request token + * @param token + * @param groupInfo + */ + bool getGroupMetaTS(const uint32_t &token, std::list &groupInfo); + + /*! + * retrieves message meta data associated to a request token + * @param token token to be redeemed + * @param msgInfo the meta data to be retrieved for token store here + */ + bool getMsgMetaTS(const uint32_t &token, GxsMsgMetaMap &msgInfo); + + /*! + * retrieves group data associated to a request token + * @param token token to be redeemed for grpitem retrieval + * @param grpItem the items to be retrieved for token are stored here + */ + bool getGroupDataTS(const uint32_t &token, std::vector& grpItem); + + + + /*! + * retrieves message data associated to a request token + * @param token token to be redeemed for message item retrieval + * @param msgItems + */ + bool getMsgDataTS(const uint32_t &token, DummyMsgMap& msgItems); + + /*! + * Retrieve msg related list for a given token sectioned by group Ids + * @param token token to be redeemed + * @param msgIds a map of grpMsgIdPair -> msgList (vector) + */ + bool getMsgRelatedListTS(const uint32_t &token, MsgRelatedIdResult &msgIds); + + /*! + * retrieves msg related data msgItems as a map of msg-grpID pair to vector + * of items + * @param token token to be redeemed + * @param msgItems map of msg items + */ + bool getMsgRelatedDataTS(const uint32_t &token, GxsMsgRelatedDataMap& msgItems); + + + void setGroupSubscribeFlagTS(uint32_t& token, const RsGxsGroupId& grpId, const uint32_t& status, const uint32_t& mask); + + void setGroupStatusFlagTS(uint32_t& token, const RsGxsGroupId& grpId, const uint32_t& status, const uint32_t& mask); + + void setGroupServiceStringTS(uint32_t& token, const RsGxsGroupId& grpId, const std::string& servString); + + void setMsgStatusFlagTS(uint32_t& token, const RsGxsGrpMsgIdPair& msgId, const uint32_t& status, const uint32_t& mask); + + void setMsgServiceStringTS(uint32_t& token, const RsGxsGrpMsgIdPair& msgId, const std::string& servString ); + + void service_tick(); + +}; + +#endif // GENEXCHANGETESTSERVICE_H diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.cc b/tests/unittests/libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.cc new file mode 100644 index 000000000..8b2eacd88 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.cc @@ -0,0 +1,18 @@ +/* + * gxsmsgrelatedtest.cpp + * + * Created on: 27 Apr 2013 + * Author: crispy + */ + +#include "gxsmsgrelatedtest.h" + +GxsMsgRelatedTest::GxsMsgRelatedTest() { + // TODO Auto-generated constructor stub + +} + +GxsMsgRelatedTest::~GxsMsgRelatedTest() { + // TODO Auto-generated destructor stub +} + diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.h b/tests/unittests/libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.h new file mode 100644 index 000000000..2277142d9 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.h @@ -0,0 +1,25 @@ +/* + * gxsmsgrelatedtest.h + * + * Created on: 27 Apr 2013 + * Author: crispy + */ + +#ifndef GXSMSGRELATEDTEST_H_ +#define GXSMSGRELATEDTEST_H_ + +#include "genexchangetester.h" + +class GxsMsgRelatedTest: public GenExchangeTest { +public: + GxsMsgRelatedTest(); + virtual ~GxsMsgRelatedTest(); + + // request msg related tests + bool testMsgRelatedChildIdRetrieval(); + bool testMsgRelatedChildDataRetrieval(); + bool testMsgRelatedChildDataRetrieval_Multi(); + bool testMsgAllVersions(); +}; + +#endif /* GXSMSGRELATEDTEST_H_ */ diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishgrouptest.cc b/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishgrouptest.cc new file mode 100644 index 000000000..d62a9ed60 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishgrouptest.cc @@ -0,0 +1,301 @@ +/* + * gxspublishgrouptest.cc + * + * Created on: 27 Apr 2013 + * Author: crispy + */ + +#include "gxspublishgrouptest.h" +#include "libretroshare/serialiser/support.h" + +#define POLLING_TIME_OUT 5 + +GxsPublishGroupTest::GxsPublishGroupTest(GenExchangeTestService* const testService, + RsGeneralDataService* dataService) + : GenExchangeTest(testService, dataService, POLLING_TIME_OUT) +{ + +} + +GxsPublishGroupTest::~GxsPublishGroupTest() +{ +} + +bool GxsPublishGroupTest::testGrpSubmissionRetrieval() +{ + + setUp(); + + GenExchangeTestService* testService = getTestService(); + RsTokenService* tokenService = getTokenService(); + + // create some random grps to allow msg testing + + RsDummyGrp* dgrp1 = new RsDummyGrp(); + RsDummyGrp* dgrp2 = new RsDummyGrp(); + RsDummyGrp* dgrp3 = new RsDummyGrp(); + + RsDummyGrp* dgrp1_copy = new RsDummyGrp(); + RsDummyGrp* dgrp2_copy = new RsDummyGrp(); + RsDummyGrp* dgrp3_copy = new RsDummyGrp(); + + init(*dgrp1); + init(*dgrp2); + init(*dgrp3); + + RsTokReqOptions opts; + opts.mReqType = 45000; + uint32_t token; + RsGxsGroupId grpId; + + std::vector groupsPublished; + + *dgrp1_copy = *dgrp1; + testService->publishDummyGrp(token, dgrp1); + pollForGrpAcknowledgement(token, grpId); + dgrp1_copy->meta.mGroupId = grpId; + groupsPublished.push_back(dgrp1_copy); + + *dgrp2_copy = *dgrp2; + testService->publishDummyGrp(token, dgrp2); + pollForGrpAcknowledgement(token, grpId); + dgrp2_copy->meta.mGroupId = grpId; + groupsPublished.push_back(dgrp2_copy); + + *dgrp3_copy = *dgrp3; + testService->publishDummyGrp(token, dgrp3); + pollForGrpAcknowledgement(token, grpId); + dgrp3_copy->meta.mGroupId = grpId; + groupsPublished.push_back(dgrp3_copy); + + + storeToGrpDataOutList(groupsPublished); + + opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA; + std::list grpIds; + tokenService->requestGroupInfo(token, 0, opts); + + pollForToken(token, opts, true); + + + bool ok = compareGrpData(); + + breakDown(); + + return ok; +} + +bool GxsPublishGroupTest::testSpecificGrpRetrieval() +{ + setUp(); + + GenExchangeTestService* testService = getTestService(); + RsTokenService* tokenService = getTokenService(); + + // create some random grps to allow msg testing + + RsDummyGrp* dgrp1 = new RsDummyGrp(); + RsDummyGrp* dgrp2 = new RsDummyGrp(); + RsDummyGrp* dgrp3 = new RsDummyGrp(); + + RsDummyGrp* dgrp1_copy = new RsDummyGrp(); + RsDummyGrp* dgrp2_copy = new RsDummyGrp(); + + init(*dgrp1); + init(*dgrp2); + init(*dgrp3); + + RsTokReqOptions opts; + opts.mReqType = 45000; + uint32_t token; + RsGxsGroupId grpId; + + std::vector groupsPublished; + std::list grpIds; + + *dgrp1_copy = *dgrp1; + testService->publishDummyGrp(token, dgrp1); + pollForGrpAcknowledgement(token, grpId); + dgrp1_copy->meta.mGroupId = grpId; + groupsPublished.push_back(dgrp1_copy); + grpIds.push_back(grpId); + + *dgrp2_copy = *dgrp2; + testService->publishDummyGrp(token, dgrp2); + pollForGrpAcknowledgement(token, grpId); + dgrp2_copy->meta.mGroupId = grpId; + groupsPublished.push_back(dgrp2_copy); + grpIds.push_back(grpId); + + + testService->publishDummyGrp(token, dgrp3); + pollForGrpAcknowledgement(token, grpId); + + + storeToGrpDataOutList(groupsPublished); + + opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA; + + tokenService->requestGroupInfo(token, 0, opts, grpIds); + + pollForToken(token, opts, true); + + + bool ok = compareGrpData(); + + breakDown(); + + return ok; +} + +bool GxsPublishGroupTest::testGrpIdRetrieval() +{ + setUp(); + + std::list grpIds; + createGrps(5, grpIds); + storeToGrpIdsOutList(grpIds); + RsTokReqOptions opts; + opts.mReqType = GXS_REQUEST_TYPE_GROUP_IDS; + uint32_t token; + + getTokenService()->requestGroupInfo(token, 0, opts); + + pollForToken(token, opts, true); + + bool ok = compareGrpIds(); + + breakDown(); + + return ok; +} + +bool GxsPublishGroupTest::testUpdateGroup() +{ + setUp(); + + GenExchangeTestService* testService = getTestService(); + RsTokenService* tokenService = getTokenService(); + +// create some random grps to allow msg testing + + RsDummyGrp* dgrp1 = new RsDummyGrp(); + RsDummyGrp* dgrp2 = new RsDummyGrp(); + + RsDummyGrp* dgrp2_copy = new RsDummyGrp(); + + init(*dgrp1); + init(*dgrp2); + + RsTokReqOptions opts; + opts.mReqType = 45000; + uint32_t token; + RsGxsGroupId grpId; + + std::vector groupsPublished; + std::list grpIds; + + std::string name = dgrp1->meta.mGroupName; + *dgrp2 = *dgrp1; + testService->publishDummyGrp(token, dgrp1); + bool ok = pollForGrpAcknowledgement(token, grpId); + + grpIds.push_back(grpId); + RsGxsGroupUpdateMeta updateMeta(grpId); + + updateMeta.setMetaUpdate(RsGxsGroupUpdateMeta::NAME, name); + randString(SHORT_STR, dgrp2->grpData); + dgrp2->meta.mGroupId = grpId; + *dgrp2_copy = *dgrp2; + dgrp2->grpData ="ojfosfjsofjsof"; + testService->updateDummyGrp(token, updateMeta, dgrp2); + ok &= pollForGrpAcknowledgement(token, grpId); + + groupsPublished.push_back(dgrp2_copy); + + opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA; + + tokenService->requestGroupInfo(token, 0, opts, grpIds); + + pollForToken(token, opts, true); + + + ok &= compareGrpData(); + + breakDown(); + + return ok; + +} + +bool GxsPublishGroupTest::testGrpMetaRetrieval() +{ + + setUp(); + + GenExchangeTestService* testService = getTestService(); + + // create some random grps to allow msg testing + + RsDummyGrp* dgrp1 = new RsDummyGrp(); + RsDummyGrp* dgrp2 = new RsDummyGrp(); + RsDummyGrp* dgrp3 = new RsDummyGrp(); + + init(*dgrp1); + init(*dgrp2); + init(*dgrp3); + + RsTokReqOptions opts; + opts.mReqType = 45000; + uint32_t token; + RsGxsGroupId grpId; + + RsGroupMetaData meta1(dgrp1->meta); + RsGroupMetaData meta2(dgrp2->meta); + RsGroupMetaData meta3(dgrp3->meta); + + std::list groupsMetaPublished; + + testService->publishDummyGrp(token, dgrp1); + pollForGrpAcknowledgement(token, grpId); + meta1.mGroupId = grpId; + groupsMetaPublished.push_back(meta1); + + testService->publishDummyGrp(token, dgrp2); + pollForGrpAcknowledgement(token, grpId); + meta2.mGroupId = grpId; + groupsMetaPublished.push_back(meta2); + + testService->publishDummyGrp(token, dgrp3); + pollForGrpAcknowledgement(token, grpId); + meta3.mGroupId = grpId; + groupsMetaPublished.push_back(meta3); + + storeToGrpMetaOutList(groupsMetaPublished); + + opts.mReqType = GXS_REQUEST_TYPE_GROUP_META; + std::list grpIds; + + getTokenService()->requestGroupInfo(token, 0, opts); + + pollForToken(token, opts, true); + + bool ok = compareGrpMeta(); + + breakDown(); + + return ok; +} + +void GxsPublishGroupTest::runTests() +{ +// CHECK(testGrpSubmissionRetrieval()); +// CHECK(testGrpIdRetrieval()); +// CHECK(testGrpMetaRetrieval()); + // CHECK(testSpecificGrpRetrieval()); + EXPECT_TRUE(testUpdateGroup()); +} + + + + diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishgrouptest.h b/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishgrouptest.h new file mode 100644 index 000000000..a0f642828 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishgrouptest.h @@ -0,0 +1,36 @@ +/* + * gxspublishgrouptest.h + * + * Created on: 27 Apr 2013 + * Author: crispy + */ + +#ifndef GXSPUBLISHGROUPTEST_H_ +#define GXSPUBLISHGROUPTEST_H_ + +#include "genexchangetester.h" + +class GxsPublishGroupTest : public GenExchangeTest { +public: + + GxsPublishGroupTest(GenExchangeTestService* const testService, + RsGeneralDataService* dataService); + virtual ~GxsPublishGroupTest(); + + void runTests(); + +private: + + // group tests + bool testGrpSubmissionRetrieval(); + bool testSpecificGrpRetrieval(); + bool testGrpIdRetrieval(); + bool testGrpMetaRetrieval(); + bool testUpdateGroup(); + + +private: + +}; + +#endif /* GXSPUBLISHGROUPTEST_H_ */ diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishmsgtest.cc b/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishmsgtest.cc new file mode 100644 index 000000000..80dc96cb3 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishmsgtest.cc @@ -0,0 +1,76 @@ +/* + * gxspublishmsgtest.cpp + * + * Created on: 27 Apr 2013 + * Author: crispy + */ + +#include + +#include "gxspublishmsgtest.h" + +#define POLLING_TIME_OUT 5 + +GxsPublishMsgTest::GxsPublishMsgTest(GenExchangeTestService* const testService, + RsGeneralDataService* dataService) + : GenExchangeTest(testService, dataService, POLLING_TIME_OUT) +{ +} + +GxsPublishMsgTest::~GxsPublishMsgTest() +{ +} + +void GxsPublishMsgTest::runTests() +{ + EXPECT_TRUE(testMsgSubmissionRetrieval()); +} + +bool GxsPublishMsgTest::testMsgSubmissionRetrieval() +{ + // start up + setUp(); + std::list grpIds; + createGrps(4, grpIds); + + /********************/ + + RsDummyMsg* msg = new RsDummyMsg(); + init(*msg); + + msg->meta.mGroupId = grpIds.front(); + uint32_t token; + RsDummyMsg* msgOut = new RsDummyMsg(); + *msgOut = *msg; + getTestService()->publishDummyMsg(token, msg); + + + RsGxsGrpMsgIdPair msgId; + pollForMsgAcknowledgement(token, msgId); + msgOut->meta.mMsgId = msgId.second; + + DummyMsgMap msgMap; + std::vector msgV; + msgV.push_back(msgOut); + msgMap[msgOut->meta.mGroupId] = msgV; + storeToMsgDataOutMaps(msgMap); + + + RsTokReqOptions opts; + opts.mReqType = GXS_REQUEST_TYPE_MSG_DATA; + + getTokenService()->requestMsgInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, grpIds); + + // poll again + pollForToken(token, opts, true); + + bool ok = compareMsgDataMaps(); + + // complete + breakDown(); + + return ok; +} + + + diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishmsgtest.h b/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishmsgtest.h new file mode 100644 index 000000000..bcdfa6aeb --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/gxspublishmsgtest.h @@ -0,0 +1,32 @@ +/* + * gxspublishmsgtest.h + * + * Created on: 27 Apr 2013 + * Author: crispy + */ + +#ifndef GXSPUBLISHMSGTEST_H_ +#define GXSPUBLISHMSGTEST_H_ + +#include "genexchangetester.h" + +class GxsPublishMsgTest: public GenExchangeTest { +public: + GxsPublishMsgTest(GenExchangeTestService* const testService, + RsGeneralDataService* dataService); + virtual ~GxsPublishMsgTest(); + + void runTests(); + + // message tests + bool testMsgSubmissionRetrieval(); +// bool testMsgIdRetrieval(); +// bool testMsgIdRetrieval_OptParents(); +// bool testMsgIdRetrieval_OptOrigMsgId(); +// bool testMsgIdRetrieval_OptLatest(); +// bool testSpecificMsgMetaRetrieval(); + + +}; + +#endif /* GXSPUBLISHMSGTEST_H_ */ diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/rsdummyservices.cc b/tests/unittests/libretroshare/gxs/gen_exchange/rsdummyservices.cc new file mode 100644 index 000000000..4d8dd4984 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/rsdummyservices.cc @@ -0,0 +1,226 @@ + + +#include "rsdummyservices.h" + + +uint32_t RsDummySerialiser::size(RsItem *item) +{ + RsDummyMsg* msg; + RsDummyGrp* grp; + + if( (msg = dynamic_cast(item)) != NULL ) + { + return sizeDummyMsgItem(msg); + }else if( (grp = dynamic_cast(item)) != NULL ) + { + return sizeDummyGrpItem(grp); + }else + { + std::cerr << "RsDummySerialiser::size(RsItem *item) Error with dummy cast!\n"; + } + + return 0; +} + + +bool RsDummySerialiser::serialise(RsItem *item, void *data, uint32_t *size) +{ + RsDummyMsg* msg; + RsDummyGrp* grp; + + if( (msg = dynamic_cast(item)) != NULL ) + { + return serialiseDummyMsgItem(msg, data, size); + }else if( (grp = dynamic_cast(item)) != NULL ) + { + return serialiseDummyGrpItem(grp, data, size); + }else + { + std::cerr << "RsDummySerialiser::size(RsItem *item) Error with dummy cast!\n"; + } + + return false; +} + +RsItem* RsDummySerialiser::deserialise(void *data, uint32_t *size) +{ + /* get the type and size */ + uint32_t rstype = getRsItemId(data); + + if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || + (RS_SERVICE_TYPE_DUMMY != getRsItemService(rstype))) + { + return NULL; /* wrong type */ + } + + switch(getRsItemSubType(rstype)) + { + case RS_PKT_SUBTYPE_DUMMY_MSG: + return deserialiseDummyMsgItem(data, size); + case RS_PKT_SUBTYPE_DUMMY_GRP: + return deserialiseDummyGrpItem(data, size); + default: + return NULL; + } + + return NULL; +} + + +uint32_t RsDummySerialiser::sizeDummyMsgItem(RsDummyMsg *item) +{ + uint32_t s = 8; // header + s += GetTlvStringSize(item->msgData); + + return s; +} + +bool RsDummySerialiser::serialiseDummyMsgItem (RsDummyMsg *item, void *data, uint32_t *size) +{ + uint32_t tlvsize = sizeDummyMsgItem(item); + uint32_t offset = 0; + + if (*size < tlvsize) + return false; /* not enough space */ + + *size = tlvsize; + + bool ok = true; + + ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); + + /* skip the header */ + offset += 8; + + /* RsDistribMsg first */ + + ok &= SetTlvString(data, *size, &offset, 1, item->msgData); + + if (offset != tlvsize) + { + ok = false; + std::cerr << "RsDummySerialiser::serialiseDummyMsgItem Size Error! " << std::endl; + } + + return ok; +} + +RsDummyMsg * RsDummySerialiser::deserialiseDummyMsgItem(void *data, uint32_t *size) +{ + /* get the type and size */ + uint32_t rstype = getRsItemId(data); + uint32_t rssize = getRsItemSize(data); + + uint32_t offset = 0; + + + if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || + (RS_SERVICE_TYPE_DUMMY != getRsItemService(rstype)) || + (RS_PKT_SUBTYPE_DUMMY_MSG != getRsItemSubType(rstype))) + { + return NULL; /* wrong type */ + } + + if (*size < rssize) /* check size */ + return NULL; /* not enough data */ + + /* set the packet length */ + *size = rssize; + + bool ok = true; + + /* ready to load */ + RsDummyMsg *item = new RsDummyMsg(); + + /* skip the header */ + offset += 8; + + ok &= GetTlvString(data, *size, &offset, 1, item->msgData); + + if (!ok) + { + delete item; + return NULL; + } + + return item; +} + +uint32_t RsDummySerialiser::sizeDummyGrpItem(RsDummyGrp *item) +{ + uint32_t s = 8; + s += GetTlvStringSize(item->grpData); + + return s; +} + +bool RsDummySerialiser::serialiseDummyGrpItem (RsDummyGrp *item, void *data, uint32_t *size) +{ + uint32_t tlvsize = sizeDummyGrpItem(item); + uint32_t offset = 0; + + if (*size < tlvsize) + return false; /* not enough space */ + + *size = tlvsize; + + bool ok = true; + + ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize); + + /* skip the header */ + offset += 8; + + ok &= SetTlvString(data, *size, &offset, 1, item->grpData); + + if (offset != tlvsize) + { + ok = false; + std::cerr << "RsDummySerialiser::serialiseDummyGrpItem Size Error! " << std::endl; + } + + return ok; +} + +RsDummyGrp * RsDummySerialiser::deserialiseDummyGrpItem(void *data, uint32_t *size) +{ + /* get the type and size */ + uint32_t rstype = getRsItemId(data); + uint32_t rssize = getRsItemSize(data); + + uint32_t offset = 0; + + + if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) || + (RS_SERVICE_TYPE_DUMMY != getRsItemService(rstype)) || + (RS_PKT_SUBTYPE_DUMMY_GRP != getRsItemSubType(rstype))) + { + return NULL; /* wrong type */ + } + + if (*size < rssize) /* check size */ + return NULL; /* not enough data */ + + /* set the packet length */ + *size = rssize; + + bool ok = true; + + /* ready to load */ + RsDummyGrp *item = new RsDummyGrp(); + + /* skip the header */ + offset += 8; + + ok &= GetTlvString(data, *size, &offset, 1, item->grpData); + + if (!ok) + { + delete item; + return NULL; + } + + return item; +} + + diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/rsdummyservices.h b/tests/unittests/libretroshare/gxs/gen_exchange/rsdummyservices.h new file mode 100644 index 000000000..4720f6be7 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/rsdummyservices.h @@ -0,0 +1,167 @@ +#ifndef RSDUMMYSERVICES_H +#define RSDUMMYSERVICES_H + + +// dummy services to make + +#include "gxs/rsnxs.h" +#include "gxs/rsgixs.h" +#include "serialiser/rsgxsitems.h" + +class RsDummyNetService: public RsNetworkExchangeService +{ +public: + + RsDummyNetService(){ return;} + virtual ~RsDummyNetService() { } + + void setSyncAge(uint32_t age){} + + void requestGroupsOfPeer(const std::string& peerId){} + + void requestMessagesOfPeer(const std::string& peerId, const std::string& grpId){} + + void pauseSynchronisation(bool enabled) {} + + int requestMsg(const std::string& msgId, uint8_t hops){ return 0;} + + int requestGrp(const std::list& grpId, uint8_t hops) { return 0;} +}; + + + +const uint16_t RS_SERVICE_TYPE_DUMMY = 0x01; +const uint8_t RS_PKT_SUBTYPE_DUMMY_MSG = 0x02; +const uint8_t RS_PKT_SUBTYPE_DUMMY_GRP = 0x03; + + +class RsDummyMsg : public RsGxsMsgItem +{ +public: + RsDummyMsg() : RsGxsMsgItem(RS_SERVICE_TYPE_DUMMY, RS_PKT_SUBTYPE_DUMMY_MSG) { return; } + virtual ~RsDummyMsg() { return; } + + std::string msgData; + + std::ostream &print(std::ostream &out, uint16_t indent = 0){ return out; } + void clear() { msgData.clear(); } + +}; + +class RsDummyGrp : public RsGxsGrpItem +{ +public: + + RsDummyGrp() : RsGxsGrpItem(RS_SERVICE_TYPE_DUMMY, RS_PKT_SUBTYPE_DUMMY_GRP) { return; } + virtual ~RsDummyGrp() { return; } + + + std::string grpData; + void clear() { grpData.clear(); } + std::ostream &print(std::ostream &out, uint16_t indent = 0){ return out; } +}; + + + +class RsDummySerialiser : public RsSerialType +{ + +public: + + + RsDummySerialiser() + : RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_DUMMY) + { return; } + virtual ~RsDummySerialiser() { return; } + + uint32_t size(RsItem *item); + bool serialise (RsItem *item, void *data, uint32_t *size); + RsItem * deserialise(void *data, uint32_t *size); + + private: + + uint32_t sizeDummyMsgItem(RsDummyMsg *item); + bool serialiseDummyMsgItem (RsDummyMsg *item, void *data, uint32_t *size); + RsDummyMsg * deserialiseDummyMsgItem(void *data, uint32_t *size); + + uint32_t sizeDummyGrpItem(RsDummyGrp *item); + bool serialiseDummyGrpItem (RsDummyGrp *item, void *data, uint32_t *size); + RsDummyGrp * deserialiseDummyGrpItem(void *data, uint32_t *size); + + +}; + +/*! + * Dummy implementation of Gixs service for + * testing + * Limited to creating two ids upon construction which can be used + * for signing data + */ +class RsGixsDummy : public RsGixs +{ + +public: + + /*! + * constructs keys for both incoming and outgoing id (no private keys for incoming id) + * @param + * @param dummyId This is is the only id thats exists in this dummy interface + */ + RsGixsDummy(const RsGxsId& incomingId, const RsGxsId& outgoingId){} + + virtual ~RsGixsDummy(){} + + /*! + * + * @return id used for signing incoming data (should have both public and private components) + */ + const RsGxsId& getOutgoing(){ return mOutgoingId; } + + /*! + * + * @return id used for signing outgoing data(only have public parts) + */ + const RsGxsId& getIncoming(){ return mIncomingId; } + + // Key related interface - used for validating msgs and groups. + /*! + * Use to query a whether given key is available by its key reference + * @param keyref the keyref of key that is being checked for + * @return true if available, false otherwise + */ + bool haveKey(const RsGxsId &id){ return false;} + + /*! + * Use to query whether private key member of the given key reference is available + * @param keyref the KeyRef of the key being checked for + * @return true if private key is held here, false otherwise + */ + bool havePrivateKey(const RsGxsId &id){ return false; } + + // The fetchKey has an optional peerList.. this is people that had the msg with the signature. + // These same people should have the identity - so we ask them first. + /*! + * Use to request a given key reference + * @param keyref the KeyRef of the key being requested + * @return will + */ + bool requestKey(const RsGxsId &id, const std::list &peers){ return false ;} + bool requestPrivateKey(const RsGxsId &id){ return false;} + + + /*! + * Retrieves a key identity + * @param keyref + * @return a pointer to a valid profile if successful, otherwise NULL + * + */ + int getKey(const RsGxsId &id, RsTlvSecurityKey &key){ return false; } + int getPrivateKey(const RsGxsId &id, RsTlvSecurityKey &key){ return false; } // For signing outgoing messages. + +private: + + RsGxsId mIncomingId, mOutgoingId; +}; + + +#endif // RSDUMMYSERVICES_H diff --git a/tests/unittests/libretroshare/gxs/gen_exchange/rsgenexchange_test.cc b/tests/unittests/libretroshare/gxs/gen_exchange/rsgenexchange_test.cc new file mode 100644 index 000000000..8e28c17d1 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/gen_exchange/rsgenexchange_test.cc @@ -0,0 +1,41 @@ + +#include + +#include "genexchangetester.h" +#include "gxspublishgrouptest.h" +#include "gxspublishmsgtest.h" +#include "gxs/rsdataservice.h" +#include "rsdummyservices.h" + + +/*! + * It always hard to say exactly what coverage of a test would + * be ahead of time. Partly because its difficult to create the + * actual conditions of a test or the permutations of different request + * options to a module is extremely large (and there are probably ways to deal with this) + * In so far as the genexchange test is concerned we are primarily interested that it + * retrieves and stores data correctly + * The auxillary (and important) requirement is authentication and ensuring the authentication + * rules are respected. This auxillary requirement is of the "hard" situation to create as + * genexchange depends on an external module (rsidentity) for satisfying a significant sum + * of its authentication. This difficulty is solved with a dummy identity service. + * Which passes all authentications (In this respect authentication) is reserved for "online" + * testing and is relatively straight forward. + * + */ + + +TEST(libretroshare_gxs, RsGenExchange) +{ + + RsGeneralDataService* dataStore = new RsDataService("./", "testServiceDb", RS_SERVICE_TYPE_DUMMY, NULL, ""); + + // we want to use default authentication which is NO authentication :) + GenExchangeTestService testService(dataStore, NULL, NULL); + + GxsPublishGroupTest testGrpPublishing(&testService, dataStore); + testGrpPublishing.runTests(); + + //GxsPublishMsgTest testMsgPublishing(&testService, dataStore); + //testMsgPublishing.runTests(); +} diff --git a/tests/unittests/libretroshare/gxs/nxs_test/nxstesthub.cc b/tests/unittests/libretroshare/gxs/nxs_test/nxstesthub.cc new file mode 100644 index 000000000..62df3b50f --- /dev/null +++ b/tests/unittests/libretroshare/gxs/nxs_test/nxstesthub.cc @@ -0,0 +1,130 @@ +#include "nxstesthub.h" + +NxsTestHub::NxsTestHub(NxsTestScenario * nts, std::set &peers) : mTestScenario(nts) +{ + + std::set::iterator sit = peers.begin(); + + for(; sit != peers.end(); sit++) + { + std::set msgPeers = peers; + + // add peers all peers except one iterator currently points to + msgPeers.erase(*sit); + NxsNetDummyMgr* dummyMgr = new NxsNetDummyMgr(*sit, msgPeers); + RsGeneralDataService* ds = mTestScenario->getDataService(*sit); + NxsMessageTestObserver* obs = new NxsMessageTestObserver(ds); + + RsServiceInfo info; + RsGxsNetService* netService = + new RsGxsNetService(mTestScenario->getServiceType(), + ds, dummyMgr, obs, info); + + + mNetServices.insert(std::make_pair(*sit, netService)); + mObservers.insert(std::make_pair(*sit, obs)); + } + + sit = peers.begin(); + + // launch net services + for(; sit != peers.end(); sit++) + { + RsGxsNetService* n = mNetServices[*sit]; + createThread(*n); + mServices.insert(std::make_pair(*sit, n)); + } +} + +NxsTestHub::~NxsTestHub() +{ + std::map::iterator mit = mNetServices.begin(); + + for(; mit != mNetServices.end(); mit++) + delete mit->second; +} + + +void NxsTestHub::run() +{ + double timeDelta = .2; + + while(isRunning()){ + + // make thread sleep for a bit + #ifndef WINDOWS_SYS + usleep((int) (timeDelta * 1000000)); + #else + Sleep((int) (timeDelta * 1000)); + #endif + + + std::map::iterator mit = mServices.begin(); + + for(; mit != mServices.end(); mit++) + { + p3Service* s = mit->second; + s->tick(); + } + + mit = mServices.begin(); + + // collect msgs to send to peers from peers + for(; mit != mServices.end(); mit++) + { + const RsPeerId& peer = mit->first; + p3Service* s = mit->second; + + // first store all the sends from all services + RsItem* item = NULL; + + while((item = s->send()) != NULL){ + + const RsPeerId peerToReceive = item->PeerId(); + + // set the peer this item comes from + item->PeerId(peer); + mPeerQueues[peerToReceive].push_back(item); + } + + + } + + // now route items to peers + std::map >::iterator mit_queue = mPeerQueues.begin(); + + for(; mit_queue != mPeerQueues.end(); mit_queue++) + { + std::vector& queueV = mit_queue->second; + std::vector::iterator vit = queueV.begin(); + const RsPeerId peerToReceive = mit_queue->first; + for(; vit != queueV.end(); vit++) + { + + RsItem* item = *vit; + p3Service* service = mServices[peerToReceive]; + + service->receive(dynamic_cast(item)); + } + queueV.clear(); + } + } +} + +void NxsTestHub::cleanUp() +{ + std::map::iterator mit = mNetServices.begin(); + for(; mit != mNetServices.end(); mit++) + { + RsGxsNetService* n = mit->second; + n->join(); + } + + // also shut down this net service peers if this goes down + mTestScenario->cleanUp(); +} + +bool NxsTestHub::testsPassed() +{ + return false; +} diff --git a/tests/unittests/libretroshare/gxs/nxs_test/nxstesthub.h b/tests/unittests/libretroshare/gxs/nxs_test/nxstesthub.h new file mode 100644 index 000000000..b4e93b46a --- /dev/null +++ b/tests/unittests/libretroshare/gxs/nxs_test/nxstesthub.h @@ -0,0 +1,89 @@ +#ifndef NXSTESTHUB_H +#define NXSTESTHUB_H + +#include "util/rsthreads.h" +#include "gxs/rsgxsnetservice.h" +#include "nxstestscenario.h" + +// it would probably be useful if the test scenario +// provided the net dummy managers +// hence one could envision synchronising between an arbitrary number +// of peers + + +class NxsNetDummyMgr : public RsNxsNetMgr +{ + +public: + + NxsNetDummyMgr(RsPeerId ownId, std::set peers) : mOwnId(ownId), mPeers(peers) { + + } + + const RsPeerId& getOwnId() { return mOwnId; } + void getOnlineList(uint32_t serviceId, std::set& ssl_peers) { ssl_peers = mPeers; } + +private: + + RsPeerId mOwnId; + std::set mPeers; + +}; + + +/*! + * Testing of nxs services occurs through use of two services + * When a service sends this class can interrogate the send and the receives of + * + * NxsScenario stores the type of synchronisation to be tested + * Operation: + * First NxsTestHub needs to be instantiated with a test scenario + * * The scenario contains two databases to be used on the communicating pair of RsGxsNetService instances (net instances) + * The Test hub has a ticker service for the p3Services which allows the netservices to search what groups and messages they have + * and synchronise according to their subscriptions. The default is to subscribe to all groups held by other peer + * The threads for both net instances are started which begins their processing of transactions + */ +class NxsTestHub : public RsThread +{ +public: + + + /*! + * This construct the test hub + * for a give scenario in mind + */ + NxsTestHub(NxsTestScenario*, std::set& peers); + + + /*! + * + */ + virtual ~NxsTestHub(); + + /*! + * To be called only after this thread has + * been shutdown + */ + bool testsPassed(); + + /*! + * This simulates the p3Service ticker and calls both gxs net services tick methods + * Also enables transport of messages between both services + */ + void run(); + + + void cleanUp(); +private: + + std::map mServices; + std::map mNetServices; + std::map mObservers; + + std::map > mPeerQueues; + + NxsTestScenario *mTestScenario; + +}; + +#endif // NXSTESTHUB_H diff --git a/tests/unittests/libretroshare/gxs/nxs_test/nxstestscenario.cc b/tests/unittests/libretroshare/gxs/nxs_test/nxstestscenario.cc new file mode 100644 index 000000000..c4cf5c666 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/nxs_test/nxstestscenario.cc @@ -0,0 +1,177 @@ +/* + * nxstestscenario.cc + * + * Created on: 10 Jul 2012 + * Author: crispy + */ + +#include "nxstestscenario.h" +#include "gxs/rsdataservice.h" +#include "retroshare/rsgxsflags.h" +#include "data_support.h" +#include + +NxsMessageTest::NxsMessageTest(uint16_t servtype) +: mServType(servtype), mMsgTestMtx("mMsgTestMtx") +{ + +} + +std::string NxsMessageTest::getTestName() +{ + return std::string("Nxs Message Test!"); +} + +NxsMessageTest::~NxsMessageTest(){ + + std::map::iterator mit = mPeerStoreMap.begin(); + + for(; mit != mPeerStoreMap.end(); mit++) + { + delete mit->second; + } + + std::set::iterator sit = mStoreNames.begin(); + + // remove db file + for(; sit != mStoreNames.end(); sit++) + { + const std::string& name = *sit; + remove(name.c_str()); + } +} +RsGeneralDataService* NxsMessageTest::getDataService(const std::string& peer) +{ + if(mPeerStoreMap.find(peer) != mPeerStoreMap.end()) return NULL; + + RsDataService* dStore = new RsDataService("./", peer, mServType); + mStoreNames.insert(peer); + mPeerStoreMap.insert(std::make_pair(peer, dStore)); + populateStore(dStore); + + return dStore; +} + +uint16_t NxsMessageTest::getServiceType() +{ + return mServType; +} + +void NxsMessageTest::populateStore(RsGeneralDataService* dStore) +{ + + int nGrp = (rand()%2)+1; + std::vector grpIdList; + std::map grps; + RsNxsGrp* grp = NULL; + RsGxsGrpMetaData* grpMeta =NULL; + for(int i = 0; i < nGrp; i++) + { + std::pair p; + grp = new RsNxsGrp(mServType); + grpMeta = new RsGxsGrpMetaData(); + p.first = grp; + p.second = grpMeta; + init_item(*grp); + init_item(grpMeta); + grpMeta->mGroupId = grp->grpId; + grps.insert(p); + grpIdList.push_back(grp->grpId); + grpMeta = NULL; + grp = NULL; + } + + dStore->storeGroup(grps); + + int nMsgs = rand()%23; + std::map msgs; + RsNxsMsg* msg = NULL; + RsGxsMsgMetaData* msgMeta = NULL; + + for(int i=0; i p(msg, msgMeta); + + // pick a grp at random to associate the msg to + const std::string& grpId = grpIdList[rand()%nGrp]; + msgMeta->mMsgId = msg->msgId; + msgMeta->mGroupId = msg->grpId = grpId; + + msg = NULL; + msgMeta = NULL; + + msgs.insert(p); + } + + + dStore->storeMessage(msgs); + + return; +} + +void NxsMessageTest::cleanUp() +{ + + std::map::iterator mit = mPeerStoreMap.begin(); + + for(; mit != mPeerStoreMap.end(); mit++) + { + RsGeneralDataService* d = mit->second; + d->resetDataStore(); + } + + return; +} + +bool NxsMessageTest::testPassed(){ + return false; +} + +/*******************************/ + +NxsMessageTestObserver::NxsMessageTestObserver(RsGeneralDataService *dStore) + :mStore(dStore) +{ + +} + +void NxsMessageTestObserver::notifyNewGroups(std::vector &groups) +{ + std::vector::iterator vit = groups.begin(); + std::map grps; + + for(; vit != groups.end(); vit++) + { + RsNxsGrp* grp = *vit; + RsGxsGrpMetaData* meta = new RsGxsGrpMetaData(); + meta->deserialise(grp->meta.bin_data, grp->meta.bin_len); + meta->mSubscribeFlags |= GXS_SERV::GROUP_SUBSCRIBE_SUBSCRIBED; + meta->mGroupId = grp->grpId; + grps.insert(std::make_pair(grp, meta)); + } + + mStore->storeGroup(grps); +} + +void NxsMessageTestObserver::notifyNewMessages(std::vector &messages) +{ + + std::vector::iterator vit = messages.begin(); + std::map msgs; + + for(; vit != messages.end(); vit++) + { + RsNxsMsg* msg = *vit; + RsGxsMsgMetaData* meta = new RsGxsMsgMetaData(); + meta->mGroupId = msg->grpId; + meta->mMsgId = msg->msgId; + msgs.insert(std::make_pair(msg, meta)); + } + + mStore->storeMessage(msgs); +} + diff --git a/tests/unittests/libretroshare/gxs/nxs_test/nxstestscenario.h b/tests/unittests/libretroshare/gxs/nxs_test/nxstestscenario.h new file mode 100644 index 000000000..dd9fd5850 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/nxs_test/nxstestscenario.h @@ -0,0 +1,106 @@ +/* + * nxstestscenario.h + * + * Created on: 10 Jul 2012 + * Author: crispy + */ + +#ifndef NXSTESTSCENARIO_H_ +#define NXSTESTSCENARIO_H_ + +#include +#include "gxs/rsdataservice.h" +#include "gxs/rsnxsobserver.h" + +/*! + * This scenario module provides data resources + */ +class NxsTestScenario +{ + +public: + + virtual std::string getTestName() = 0; + + /*! + * @param peer + * @param namePath + * @return data service with populated with random grp/msg data, null if peer or pathname exists + */ + virtual RsGeneralDataService* getDataService(const RsPeerId& peer) = 0; + + + virtual bool testPassed() = 0; + /*! + * Service type for this test + * should correspond to serialiser service type + */ + virtual uint16_t getServiceType() = 0; + + /*! + * Call to remove files created + * in the test directory + */ + virtual void cleanUp() = 0; + + +}; + +class NxsMessageTestObserver : public RsNxsObserver +{ +public: + + NxsMessageTestObserver(RsGeneralDataService* dStore); + + /*! + * @param messages messages are deleted after function returns + */ + void notifyNewMessages(std::vector& messages); + + /*! + * @param messages messages are deleted after function returns + */ + void notifyNewGroups(std::vector& groups); + +private: + + RsGeneralDataService* mStore; + +}; + +class NxsMessageTest : public NxsTestScenario +{ + +public: + + NxsMessageTest(uint16_t servtype); + virtual ~NxsMessageTest(); + std::string getTestName(); + uint16_t getServiceType(); + RsGeneralDataService* getDataService(const RsPeerId& peer); + + /*! + * Call to remove files created + * in the test directory + */ + void cleanUp(); + + bool testPassed(); + +private: + void setUpDataBases(); + void populateStore(RsGeneralDataService* dStore); + +private: + + std::string mTestName; + std::map mPeerStoreMap; + std::set mStoreNames; + uint16_t mServType; + + RsMutex mMsgTestMtx; + +}; + + +#endif /* NXSTESTSCENARIO_H_ */ diff --git a/tests/unittests/libretroshare/gxs/nxs_test/rsgxsnetservice_test.cc b/tests/unittests/libretroshare/gxs/nxs_test/rsgxsnetservice_test.cc new file mode 100644 index 000000000..ddcc2f6c0 --- /dev/null +++ b/tests/unittests/libretroshare/gxs/nxs_test/rsgxsnetservice_test.cc @@ -0,0 +1,46 @@ +/* + * rsgxsnetservice_test.cc + * + * Created on: 11 Jul 2012 + * Author: crispy + */ + +#include "util/utest.h" +#include "nxstesthub.h" +#include "nxstestscenario.h" + +INITTEST(); + + +int main() +{ + + // first setup + NxsMessageTest msgTest(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + std::set peers; + peers.insert("PeerA"); + peers.insert("PeerB"); + NxsTestHub hub(&msgTest, peers); + + // now get things started + createThread(hub); + + double timeDelta = 50; + + // put this thread to sleep for 10 secs + // make thread sleep for a bit +#ifndef WINDOWS_SYS + usleep((int) (timeDelta * 1000000)); +#else + Sleep((int) (timeDelta * 1000)); +#endif + + hub.join(); + CHECK(hub.testsPassed()); + + hub.cleanUp(); + + FINALREPORT("RsGxsNetService Tests"); + + return TESTRESULT(); +} diff --git a/tests/unittests/libretroshare/serialiser/rsbaseitem_test.cc b/tests/unittests/libretroshare/serialiser/rsbaseitem_test.cc new file mode 100644 index 000000000..5d04fbad5 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsbaseitem_test.cc @@ -0,0 +1,157 @@ + +/* + * libretroshare/src/serialiser: rsbaseitem_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +/****************************************************************** + * tlvfileitem test. + * + * + */ + +#include + +#include +#include +#include "serialiser/rstlvfileitem.h" +#include "rstlvutil.h" + + +TEST(libretroshare_serialiser, RsTlvFileItem) +{ + RsTlvFileItem i1; + RsTlvFileItem i2; + + /* initialise */ + i1.filesize = 101010; + i1.hash = "ABCDEFEGHE"; + i1.name = "TestFile.txt"; + i1.pop = 12; + i1.age = 456; + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &i1, &i2)); + + /* check the data is the same */ + EXPECT_TRUE(i1.filesize == i2.filesize); + EXPECT_TRUE(i1.hash == i2.hash); + EXPECT_TRUE(i1.name == i2.name); + EXPECT_TRUE(i1.path == i2.path); + EXPECT_TRUE(i1.pop == i2.pop); + EXPECT_TRUE(i1.age == i2.age); + + /* do it again without optional data */ + i1.filesize = 123; + i1.name = ""; + i1.pop = 0; + i1.age = 0; + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &i1, &i2)); + + /* check the data is the same */ + EXPECT_TRUE(i1.filesize == i2.filesize); + EXPECT_TRUE(i1.hash == i2.hash); + EXPECT_TRUE(i1.name == i2.name); + EXPECT_TRUE(i1.path == i2.path); + EXPECT_TRUE(i1.pop == i2.pop); + EXPECT_TRUE(i1.age == i2.age); + + /* one more time - long file name, some optional data */ + i1.filesize = 123; + i1.name = "A Very Long File name that should fit in easily ??? with som $&%&^%* strange char (**$^%#&^$#*^%(&^ in there too!!!! ~~~!!$#(^$)$)(&%^)&\" oiyu thend"; + i1.pop = 666; + i1.age = 0; + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &i1, &i2)); + + /* check the data is the same */ + EXPECT_TRUE(i1.filesize == i2.filesize); + EXPECT_TRUE(i1.hash == i2.hash); + EXPECT_TRUE(i1.name == i2.name); + EXPECT_TRUE(i1.path == i2.path); + EXPECT_TRUE(i1.pop == i2.pop); + EXPECT_TRUE(i1.age == i2.age); +} + +TEST(libretroshare_serialiser, RsTlvFileSet) +{ + RsTlvFileSet s1; + RsTlvFileSet s2; + + int i = 0; + for(i = 0; i < 15; i++) + { + RsTlvFileItem fi; + fi.filesize = 16 + i * i; + fi.hash = "ABCDEF"; + std::ostringstream out; + out << "File" << i << "_inSet.txt"; + fi.name = out.str(); + if (i % 2 == 0) + { + fi.age = 10 * i; + } + else + { + fi.age = 0; + } + fi.pop = 0; + + s1.items.push_back(fi); + } + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &s1, &s2)); +} + +TEST(libretroshare_serialiser, RsTlvFileData) +{ + RsTlvFileData d1; + RsTlvFileData d2; + + /* initialise */ + d1.file.filesize = 101010; + d1.file.hash = "ABCDEFEGHE"; + d1.file.name = ""; + d1.file.age = 0; + d1.file.pop = 0; + + char data[15]; + d1.binData.setBinData(data, 15); + + d1.file_offset = 222; + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &d1, &d2)); + + /* check the data is the same */ + EXPECT_TRUE(d1.file.filesize == d2.file.filesize); + EXPECT_TRUE(d1.file.hash == d2.file.hash); + EXPECT_TRUE(d1.file.name == d2.file.name); + EXPECT_TRUE(d1.file.path == d2.file.path); + EXPECT_TRUE(d1.file.pop == d2.file.pop); + EXPECT_TRUE(d1.file.age == d2.file.age); + + EXPECT_TRUE(d1.file_offset == d2.file_offset); + EXPECT_TRUE(d1.binData.bin_len == d2.binData.bin_len); +} + + diff --git a/tests/unittests/libretroshare/serialiser/rsconfigitem_test.cc b/tests/unittests/libretroshare/serialiser/rsconfigitem_test.cc new file mode 100644 index 000000000..e74a215c6 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsconfigitem_test.cc @@ -0,0 +1,305 @@ +/* + * libretroshare/src/tests/serialiser: rsconfigitemstest.cc + * + * RetroShare Serialiser tests. + * + * Copyright 2011 by Christopher Evi-Parker + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include "support.h" +#include "serialiser/rsconfigitems.h" + +RsSerialType* init_item(RsPeerNetItem& rpn) +{ + randString(SHORT_STR, rpn.dyndns); + rpn.peerId.random(); + rpn.pgpId.random(); + randString(SHORT_STR, rpn.location); + + rpn.lastContact = rand()%42424; + rpn.netMode = rand()%313190; + rpn.visState = rand()%63635; + + + inet_aton("10.0.0.111", &(rpn.currentlocaladdr.sin_addr)); + rpn.currentlocaladdr.sin_port = htons(1111); + + inet_aton("123.1.2.123", &(rpn.currentremoteaddr.sin_addr)); + rpn.currentremoteaddr.sin_port = htons(1234); + + RsTlvIpAddressInfo ipa1, ipa2; + + ipa1.addr = rpn.currentlocaladdr; + ipa1.seenTime = rand()%40149013; + ipa1.source = rand()%13423; + + ipa2.addr = rpn.currentremoteaddr; + ipa2.seenTime = rand()%40139013; + ipa2.source = rand()%1343443; + + rpn.extAddrList.mList.push_back(ipa1); + rpn.extAddrList.mList.push_back(ipa2); + + rpn.localAddrList.mList.push_back(ipa1); + rpn.localAddrList.mList.push_back(ipa2); + + + return new RsPeerConfigSerialiser(); +} + +RsSerialType* init_item(RsPeerGroupItem& rpgi){ + + rpgi.flag = rand()%134344; + randString(SHORT_STR, rpgi.id); + randString(SHORT_STR, rpgi.name); + std::string p1, p2, p3; + randString(SHORT_STR, p1); + randString(SHORT_STR, p2); + randString(SHORT_STR, p3); + + rpgi.peerIds.push_back(p1); + rpgi.peerIds.push_back(p2); + rpgi.peerIds.push_back(p3); + + return new RsPeerConfigSerialiser(); +} + +RsSerialType* init_item(CompressedChunkMap& map) +{ + map._map.clear() ; + for(uint32_t i=0;i<15;++i) + map._map.push_back(rand()) ; + + return new RsTurtleSerialiser(); +} + +RsSerialType* init_item(RsPeerStunItem& rpsi) +{ + std::string p1, p2, p3; + randString(SHORT_STR, p1); + randString(SHORT_STR, p2); + randString(SHORT_STR, p3); + + rpsi.stunList.ids.push_back(p1); + rpsi.stunList.ids.push_back(p2); + rpsi.stunList.ids.push_back(p3); + + rpsi.stunList.mType = TLV_TYPE_PEERSET; + + return new RsPeerConfigSerialiser(); +} +RsSerialType* init_item(RsCacheConfig& rcc) +{ + + rcc.cachesubid = rand()%2342; + rcc.cachetypeid = rand()%323; + rcc.recvd = rand()%2252243; + rcc.size = rand()%02203; + randString(SHORT_STR, rcc.hash); + randString(SHORT_STR, rcc.name); + randString(SHORT_STR, rcc.path); + randString(SHORT_STR, rcc.pid); + + return new RsCacheConfigSerialiser(); +} + +RsSerialType* init_item(RsFileTransfer& rft) +{ + + std::string p1, p2, p3; + randString(SHORT_STR, p1); + randString(SHORT_STR, p2); + randString(SHORT_STR, p3); + + rft.allPeerIds.ids.push_back(p1); + rft.allPeerIds.ids.push_back(p2); + rft.allPeerIds.ids.push_back(p3); + rft.allPeerIds.mType = TLV_TYPE_PEERSET; + +// +// rft.compressed_chunk_map._map.clear(); +// const int mapSize = 15; +// rft.compressed_chunk_map._map.resize(mapSize); +// for(int i=0; i& left, + const std::list& right) +{ + std::list::const_iterator cit1 = left.begin(), + cit2 = right.begin(); + + for(; cit1 != left.end() ; cit1++, cit2++){ + + if(*cit1 != *cit2) + return false; + } + + return true; +} + +bool operator!=(const sockaddr_in& left, const sockaddr_in& right) +{ + if(left.sin_addr.s_addr != right.sin_addr.s_addr) return true; + if(left.sin_port != right.sin_port) return true; + + return false; +} + +bool operator!=(const RsTlvIpAddressInfo& left, const RsTlvIpAddressInfo& right) +{ + + if(left.addr != right.addr) return true; + if(left.seenTime != right.seenTime) return true; + if(left.source != right.source) return true; + + return false; +} + +bool operator==(const RsPeerGroupItem& left, const RsPeerGroupItem& right) +{ + if(left.flag != right.flag) return false; + if(left.id != right.id) return false; + if(left.name != right.name) return false; + if(left.peerIds != right.peerIds) return false; + + return true; +} + +bool operator!=(const std::list& left, + const std::list& right) +{ + std::list::const_iterator cit1 = left.begin(), + cit2 = right.begin(); + + for(; cit1 != left.end(); cit1++, cit2++){ + + if(*cit1 != *cit2) + return true; + } + + return false; +} + +bool operator==(const RsPeerStunItem& left, const RsPeerStunItem& right) +{ + if(!(left.stunList == right.stunList)) return false; + + return true; +} + +//bool operator==(const RsTlvPeerIdSet& left, const RsTlvPeerIdSet& right) +//{ +// if(left.mType != right.mType) return false; +// +// std::list::iterator cit1 = left.ids.begin(), +// cit2 = right.ids.begin(); +// +// for(; cit1 != left.ids.end(); cit1++, cit2++){ +// +// if(*cit1 != *cit2) +// return false; +// } +// +// return true; +//} + +bool operator==(const RsCacheConfig& left, const RsCacheConfig& right) +{ + + if(left.cachesubid != right.cachesubid) return false; + if(left.cachetypeid != right.cachetypeid) return false; + if(left.hash != right.hash) return false; + if(left.path != right.path) return false; + if(left.pid != right.pid) return false; + if(left.recvd != right.recvd) return false; + if(left.size != right.size) return false; + + return true; +} + +bool operator==(const RsFileTransfer& left, const RsFileTransfer& right) +{ + + if(!(left.allPeerIds == right.allPeerIds)) return false; + if(left.cPeerId != right.cPeerId) return false; + if(left.chunk_strategy != right.chunk_strategy) return false; + if(left.compressed_chunk_map._map != right.compressed_chunk_map._map) return false; + if(left.crate != right.crate) return false; + if(!(left.file == right.file)) return false; + if(left.flags != right.flags) return false; + if(left.in != right.in) return false; + if(left.lrate != right.lrate) return false; + if(left.ltransfer != right.ltransfer) return false; + if(left.state != right.state) return false; + if(left.transferred != right.transferred) return false; + if(left.trate != right.trate) return false; + + return true; +} + + + +TEST(libretroshare_serialiser, RsConfigItem) +{ + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); +} diff --git a/tests/unittests/libretroshare/serialiser/rsgrouteritem_test.cc b/tests/unittests/libretroshare/serialiser/rsgrouteritem_test.cc new file mode 100644 index 000000000..8d6200a0b --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsgrouteritem_test.cc @@ -0,0 +1,209 @@ +/* + * libretroshare/src/tests/serialiser: msgitem_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2010 by Christopher Evi-Parker. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include +#include + +#include "util/rsrandom.h" +#include "grouter/grouteritems.h" +#include "serialiser/rstlvutil.h" +#include "support.h" + +RsSerialType* init_item(RsGRouterGenericDataItem& cmi) +{ + cmi.data_size = lrand48()%1000 + 1000 ; + cmi.data_bytes = (uint8_t*)malloc(cmi.data_size) ; + RSRandom::random_bytes(cmi.data_bytes,cmi.data_size) ; + cmi.routing_id = RSRandom::random_u32() ; + + Sha1CheckSum cs ; + for(int i=0;i<5;++i) cs.fourbytes[i] = RSRandom::random_u32() ; + cmi.destination_key = cs ; + + return new RsGRouterSerialiser(); +} +RsSerialType* init_item(RsGRouterACKItem& cmi) +{ + cmi.mid = RSRandom::random_u32() ; + cmi.state = RSRandom::random_u32() ; + + return new RsGRouterSerialiser(); +} +RsSerialType* init_item(RsGRouterPublishKeyItem& cmi) +{ + cmi.diffusion_id = RSRandom::random_u32() ; + cmi.service_id = RSRandom::random_u32() ; + cmi.randomized_distance = RSRandom::random_f32() ; + + Sha1CheckSum cs ; + for(int i=0;i<5;++i) cs.fourbytes[i] = RSRandom::random_u32() ; + cmi.published_key = cs ; + cmi.description_string = "test key" ; + + return new RsGRouterSerialiser(); +} +RsSerialType* init_item(RsGRouterRoutingInfoItem& cmi) +{ + cmi.origin = SSLIdType::random() ; + cmi.received_time = RSRandom::random_u64() ; + cmi.status_flags = RSRandom::random_u32() ; + + cmi.data_item = new RsGRouterGenericDataItem ; + + uint32_t n = 10+(RSRandom::random_u32()%30) ; + + for(uint32_t i=0;i 0.001) return false; + if(cmiLeft.description_string != cmiRight.description_string) return false; + + return true ; +} +bool operator ==(const RsGRouterACKItem& cmiLeft,const RsGRouterACKItem& cmiRight) +{ + if(cmiLeft.mid != cmiRight.mid) return false; + if(cmiLeft.state != cmiRight.state) return false; + + return true; +} +bool operator ==(const RsGRouterMatrixCluesItem& cmiLeft,const RsGRouterMatrixCluesItem& cmiRight) +{ + if(!(cmiLeft.destination_key == cmiRight.destination_key)) return false; + if(cmiLeft.clues.size() != cmiRight.clues.size()) return false; + + std::list::const_iterator itl = cmiLeft.clues.begin() ; + std::list::const_iterator itr = cmiRight.clues.begin() ; + + while(itl != cmiLeft.clues.end()) + { + if( (*itl).friend_id != (*itr).friend_id) return false ; + if( (*itl).time_stamp != (*itr).time_stamp) return false ; + + ++itl ; + ++itr ; + } + + return true; +} +bool operator ==(const RsGRouterMatrixFriendListItem& cmiLeft,const RsGRouterMatrixFriendListItem& cmiRight) +{ + if(cmiLeft.reverse_friend_indices.size() != cmiRight.reverse_friend_indices.size()) return false; + + for(uint32_t i=0;i::const_iterator itl(cmiLeft.tried_friends.begin()) ; + std::list::const_iterator itr(cmiRight.tried_friends.begin()) ; + + while(itl != cmiLeft.tried_friends.end()) + { + if( (*itl).friend_id != (*itr).friend_id) return false ; + if( (*itl).time_stamp != (*itr).time_stamp) return false ; + + ++itl ; + ++itr ; + } + + if(!(*cmiLeft.data_item == *cmiRight.data_item)) return false ; + + return true; +} + + +TEST(libretroshare_serialiser, RsGRouterItem) +{ + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); +} + + + + + diff --git a/tests/unittests/libretroshare/serialiser/rsgxsiditem_test.cc b/tests/unittests/libretroshare/serialiser/rsgxsiditem_test.cc new file mode 100644 index 000000000..4e91abfba --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsgxsiditem_test.cc @@ -0,0 +1,58 @@ + +/* + * libretroshare/src/serialiser: rsturtleitems_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Cyril Soler + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +/****************************************************************** + */ +#include + +#include "serialiser/rsgxsiditems.h" +#include "support.h" + + +bool operator==(const RsGxsIdGroupItem& it1,const RsGxsIdGroupItem& it2) +{ + if(it1.group.mPgpIdSign != it2.group.mPgpIdSign) return false ; + + return true ; +} +RsSerialType* init_item(RsGxsIdGroupItem& item) +{ + item.group.mPgpIdSign = "hello"; + item.group.mPgpKnown = false; + + return new RsGxsIdSerialiser(); +} + + +TEST(libretroshare_serialiser, RsGxsIdItem) +{ + for(uint32_t i=0;i<20;++i) + { + test_RsItem< RsGxsIdGroupItem >(); + } +} + + diff --git a/tests/unittests/libretroshare/serialiser/rsgxsupdateitem_test.cc b/tests/unittests/libretroshare/serialiser/rsgxsupdateitem_test.cc new file mode 100644 index 000000000..a8e100c09 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsgxsupdateitem_test.cc @@ -0,0 +1,105 @@ +/* + * rsgxsupdateitem_test.cc + * + * Created on: 9 Dec 2013 + * Author: crispy + */ + +#include + +#include "support.h" +#include "serialiser/rsgxsupdateitems.h" +#define RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM 0x0010 + +RsSerialType* init_item(RsGxsGrpUpdateItem& i) +{ + i.clear(); + i.grpUpdateTS = rand()%2424; + i.peerId.random(); + return new RsGxsUpdateSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +RsSerialType* init_item(RsGxsMsgUpdateItem& i) +{ + i.clear(); + i.peerId.random(); + int numUpdates = rand()%123; + + RsPeerId peer; + peer.random(); + for(int j=0; j < numUpdates; j++) + { + i.msgUpdateTS.insert(std::make_pair(peer, rand()%45)); + } + + return new RsGxsUpdateSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +RsSerialType* init_item(RsGxsServerGrpUpdateItem& i) +{ + i.clear(); + i.grpUpdateTS = rand()%2424; + + return new RsGxsUpdateSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +RsSerialType* init_item(RsGxsServerMsgUpdateItem& i) +{ + i.clear(); + i.grpId.random(); + i.msgUpdateTS = rand()%4252; + return new RsGxsUpdateSerialiser(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} + +bool operator ==(const RsGxsGrpUpdateItem& l, const RsGxsGrpUpdateItem& r) +{ + bool ok = l.grpUpdateTS == r.grpUpdateTS; + ok &= l.peerId == r.peerId; + + return ok; +} + +bool operator ==(const RsGxsMsgUpdateItem& l, const RsGxsMsgUpdateItem& r) +{ + bool ok = l.peerId == r.peerId; + + const std::map& lUp = l.msgUpdateTS, rUp = r.msgUpdateTS; + + ok &= lUp.size() == rUp.size(); + + std::map::const_iterator lit = lUp.begin(), rit; + + for(; lit != lUp.end(); lit++) + { + RsGxsGroupId key = lit->first; + if((rit = rUp.find(key)) != rUp.end()) + ok &= lit->second == rit->second; + else + return false; + } + + return ok; +} + +bool operator ==(const RsGxsServerGrpUpdateItem& l, + const RsGxsServerGrpUpdateItem& r) +{ + return l.grpUpdateTS == r.grpUpdateTS; +} + +bool operator ==(const RsGxsServerMsgUpdateItem& l, + const RsGxsServerMsgUpdateItem& r) +{ + bool ok = l.grpId == r.grpId; + ok &= l.msgUpdateTS == r.msgUpdateTS; + return ok; +} + + +TEST(libretroshare_serialiser, RsGxsGrpUpateItem) +{ + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} diff --git a/tests/unittests/libretroshare/serialiser/rsmsgitem_test.cc b/tests/unittests/libretroshare/serialiser/rsmsgitem_test.cc new file mode 100644 index 000000000..ba14f4b03 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsmsgitem_test.cc @@ -0,0 +1,352 @@ +/* + * libretroshare/src/tests/serialiser: msgitem_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2010 by Christopher Evi-Parker. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include "util/rsrandom.h" +#include "serialiser/rsmsgitems.h" + +#include "support.h" +#include "rstlvutil.h" + + +RsSerialType* init_item(RsChatMsgItem& cmi) +{ + cmi.chatFlags = rand()%34; + cmi.sendTime = rand()%422224; + randString(LARGE_STR, cmi.message); + + return new RsChatSerialiser(); +} +RsSerialType* init_item(RsChatLobbyListRequestItem& cmi) +{ + return new RsChatSerialiser(); +} +RsSerialType* init_item(RsChatLobbyListItem& cmi) +{ + int n = rand()%20 ; + + cmi.lobby_ids.resize(n) ; + cmi.lobby_names.resize(n) ; + cmi.lobby_counts.resize(n) ; + + for(int i=0;i(&cmi)) ; + + cmi.msg_id = RSRandom::random_u64() ; + cmi.lobby_id = RSRandom::random_u64() ; + cmi.nick = "My nickname" ; + cmi.subpacket_id = rand()%256 ; + cmi.parent_msg_id = RSRandom::random_u64() ; + + return serial ; +} +RsSerialType *init_item(RsChatLobbyEventItem& cmi) +{ + cmi.event_type = rand()%256 ; + randString(20, cmi.string1); + + return new RsChatSerialiser(); +} + +RsSerialType* init_item(RsChatLobbyInviteItem& cmi) +{ + cmi.lobby_id = RSRandom::random_u64() ; + cmi.lobby_name = "Name of the lobby" ; + + return new RsChatSerialiser(); +} + +RsSerialType* init_item(RsPrivateChatMsgConfigItem& pcmi) +{ + pcmi.configPeerId.random(); + pcmi.chatFlags = rand()%34; + pcmi.configFlags = rand()%21; + pcmi.sendTime = rand()%422224; + randString(LARGE_STR, pcmi.message); + pcmi.recvTime = rand()%344443; + + return new RsChatSerialiser(); +} + +RsSerialType* init_item(RsChatStatusItem& csi) +{ + + randString(SHORT_STR, csi.status_string); + csi.flags = rand()%232; + + return new RsChatSerialiser(); + +} + +RsSerialType* init_item(RsChatAvatarItem& cai) +{ + std::string image_data; + randString(LARGE_STR, image_data); + cai.image_data = new unsigned char[image_data.size()]; + + memcpy(cai.image_data, image_data.c_str(), image_data.size()); + cai.image_size = image_data.size(); + + return new RsChatSerialiser(); +} + +RsSerialType* init_item(RsMsgItem& mi) +{ + init_item(mi.attachment); + init_item(mi.rspeerid_msgbcc); + init_item(mi.rspeerid_msgcc); + init_item(mi.rspeerid_msgto); + + randString(LARGE_STR, mi.message); + randString(SHORT_STR, mi.subject); + + mi.msgId = rand()%324232; + mi.recvTime = rand()%44252; + mi.sendTime = mi.recvTime; + mi.msgFlags = mi.recvTime; + + return new RsMsgSerialiser(true); +} + +RsSerialType* init_item(RsMsgTagType& mtt) +{ + mtt.rgb_color = rand()%5353; + mtt.tagId = rand()%24242; + randString(SHORT_STR, mtt.text); + + return new RsMsgSerialiser(); +} + + +RsSerialType* init_item(RsMsgTags& mt) +{ + mt.msgId = rand()%3334; + + int i; + for (i = 0; i < 10; i++) { + mt.tagIds.push_back(rand()%21341); + } + + return new RsMsgSerialiser(); +} + +RsSerialType* init_item(RsMsgSrcId& ms) +{ + ms.msgId = rand()%434; + ms.srcId.random(); + + return new RsMsgSerialiser(); +} + +RsSerialType* init_item(RsMsgParentId& ms) +{ + ms.msgId = rand()%354; + ms.msgParentId = rand()%476; + + return new RsMsgSerialiser(); +} + +bool operator ==(const RsChatLobbyListItem& cmiLeft,const RsChatLobbyListItem& cmiRight) +{ + if(cmiLeft.lobby_ids.size() != cmiRight.lobby_ids.size()) return false; + if(cmiLeft.lobby_names.size() != cmiRight.lobby_names.size()) return false; + if(cmiLeft.lobby_counts.size() != cmiRight.lobby_counts.size()) return false; + + for(uint32_t i=0;i(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); +} + + + + + diff --git a/tests/unittests/libretroshare/serialiser/rsnxsitems_test.cc b/tests/unittests/libretroshare/serialiser/rsnxsitems_test.cc new file mode 100644 index 000000000..252e03781 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsnxsitems_test.cc @@ -0,0 +1,21 @@ + +#include "support.h" +#include "libretroshare/gxs/common/data_support.h" +#include "serialiser/rsnxsitems.h" + + +#define NUM_BIN_OBJECTS 5 +#define NUM_SYNC_MSGS 8 +#define NUM_SYNC_GRPS 5 + + +TEST(libretroshare_serialiser, RsNxsItem) +{ + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); + test_RsItem(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM); +} diff --git a/tests/unittests/libretroshare/serialiser/rsphotoitem_test.cc b/tests/unittests/libretroshare/serialiser/rsphotoitem_test.cc new file mode 100644 index 000000000..70ce26ef3 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsphotoitem_test.cc @@ -0,0 +1,133 @@ +/* + * libretroshare/src/test rsphotoitem_test.cc + * + * Test for photo item serialisation + * + * Copyright 2012-2012 by Christopher Evi-Parker + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + + +#include "support.h" +#include "serialiser/rsphotoitems.h" + + +RsSerialType* init_item(RsGxsPhotoAlbumItem &album) +{ + RsPhotoAlbum& a = album.album; + + randString(SHORT_STR, a.mCaption); + randString(SHORT_STR, a.mCategory); + randString(SHORT_STR, a.mDescription); + randString(SHORT_STR, a.mHashTags); + randString(SHORT_STR, a.mOther); + randString(SHORT_STR, a.mPhotoPath); + randString(SHORT_STR, a.mPhotographer); + randString(SHORT_STR, a.mWhen); + randString(SHORT_STR, a.mWhere); + randString(SHORT_STR, a.mThumbnail.type); + std::string rStr; + randString(SHORT_STR, rStr); + + a.mThumbnail.data = new uint8_t[SHORT_STR]; + memcpy(a.mThumbnail.data, rStr.data(), SHORT_STR); + a.mThumbnail.size = SHORT_STR; + + return new RsGxsPhotoSerialiser(); +} + +RsSerialType* init_item(RsGxsPhotoPhotoItem &photo) +{ + + RsPhotoPhoto& p = photo.photo; + + randString(SHORT_STR, p.mCaption); + randString(SHORT_STR, p.mCategory); + randString(SHORT_STR, p.mDescription); + randString(SHORT_STR, p.mHashTags); + randString(SHORT_STR, p.mOther); + randString(SHORT_STR, p.mPhotographer); + randString(SHORT_STR, p.mWhen); + randString(SHORT_STR, p.mWhere); + randString(SHORT_STR, p.mThumbnail.type); + std::string rStr; + randString(SHORT_STR, rStr); + + p.mThumbnail.data = new uint8_t[SHORT_STR]; + memcpy(p.mThumbnail.data, rStr.data(), SHORT_STR); + p.mThumbnail.size = SHORT_STR; + + return new RsGxsPhotoSerialiser(); +} + +bool operator == (RsPhotoThumbnail& l, RsPhotoThumbnail& r) +{ + if(l.size != r.size) return false; + if(l.type != r.type) return false; + if(memcmp(l.data, r.data,l.size) != 0) return false; + + return true; +} + + +bool operator == (RsGxsPhotoAlbumItem& l, RsGxsPhotoAlbumItem& r) +{ + RsPhotoAlbum& la = l.album; + RsPhotoAlbum& ra = r.album; + + if(la.mCaption != ra.mCaption) return false; + if(la.mCategory != ra.mCategory) return false; + if(la.mDescription != ra.mDescription) return false; + if(la.mHashTags != ra.mHashTags) return false; + if(la.mOther != ra.mOther) return false; + if(la.mPhotographer!= ra.mPhotographer) return false; + if(la.mPhotoPath != ra.mPhotoPath) return false; + if(la.mWhere != ra.mWhere) return false; + if(la.mWhen != ra.mWhen) return false; + if(!(la.mThumbnail == ra.mThumbnail)) return false; + + return true; +} + + + +bool operator == (RsGxsPhotoPhotoItem& l, RsGxsPhotoPhotoItem& r) +{ + RsPhotoPhoto& la = l.photo; + RsPhotoPhoto& ra = r.photo; + + if(la.mCaption != ra.mCaption) return false; + if(la.mCategory != ra.mCategory) return false; + if(la.mDescription != ra.mDescription) return false; + if(la.mHashTags != ra.mHashTags) return false; + if(la.mOther != ra.mOther) return false; + if(la.mPhotographer!= ra.mPhotographer) return false; + if(la.mWhere != ra.mWhere) return false; + if(la.mWhen != ra.mWhen) return false; + if(!(la.mThumbnail == ra.mThumbnail)) return false; + + return true; +} + + +TEST(libretroshare_serialiser, RsPhotoItem_test) +{ + test_RsItem(); + test_RsItem(); +} diff --git a/tests/unittests/libretroshare/serialiser/rsstatusitem_test.cc b/tests/unittests/libretroshare/serialiser/rsstatusitem_test.cc new file mode 100644 index 000000000..c9fc6cb61 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsstatusitem_test.cc @@ -0,0 +1,52 @@ +/* + * libretroshare/src/tests/serialiser: rsstatusitem_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2010 by Christopher Evi-Parker. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + + +#include "support.h" +#include "serialiser/rsstatusitems.h" + +RsSerialType* init_item(RsStatusItem& rsi) +{ + + rsi.sendTime = rand()%5353; + rsi.status = rand()%2032; + return new RsStatusSerialiser(); +} + +bool operator ==(RsStatusItem& rsi1, RsStatusItem& rsi2) +{ + // note: recv time is not serialised + + if(rsi1.sendTime != rsi2.sendTime) return false; + if(rsi1.status != rsi2.status) return false; + + return true; +} + + +TEST(libretroshare_serialiser, test_RsStatusItem) +{ + test_RsItem(); +} diff --git a/tests/unittests/libretroshare/serialiser/rstlvutil.cc b/tests/unittests/libretroshare/serialiser/rstlvutil.cc new file mode 100644 index 000000000..e7b3b0bc9 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rstlvutil.cc @@ -0,0 +1,177 @@ + +/* + * libretroshare/src/serialiser: rstlvutil.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + + +/* some utility functions mainly for debugging + * + * + * + */ + +#include + +#include "rstlvutil.h" + +#include "serialiser/rstlvbase.h" +#include "serialiser/rstlvitem.h" +#include "util/rsstring.h" + +#include +#include + +#if 0 +/* print out a packet */ +#include +#include + + +#endif + +void displayRawPacket(std::ostream &out, void *data, uint32_t size) +{ + uint32_t i; + std::string sout; + rs_sprintf(sout, "DisplayRawPacket: Size: %ld", size); + + for(i = 0; i < size; i++) + { + if (i % 16 == 0) + { + sout += "\n"; + } + rs_sprintf_append(sout, "%02x:", (int) (((unsigned char *) data)[i])); + } + + out << sout << std::endl; +} + + +#define WHOLE_64K_SIZE 65536 + +int test_SerialiseTlvItem(std::ostream &str, RsTlvItem *in, RsTlvItem *out) +{ + uint16_t initsize = in->TlvSize(); + uint32_t serialOffset = 0; + uint32_t deserialOffset = 0; + + str << "test_SerialiseTlvItem() Testing ... Print/Serialise/Deserialise"; + str << std::endl; + + + /* some space to serialise into */ + unsigned char serbuffer[WHOLE_64K_SIZE]; + + EXPECT_TRUE(in->SetTlv(serbuffer, WHOLE_64K_SIZE, &serialOffset)); + + EXPECT_TRUE(serialOffset == initsize); /* check that the offset matches the size */ + EXPECT_TRUE(in->TlvSize() == initsize); /* check size hasn't changed */ + + /* now we try to read it back in! */ + EXPECT_TRUE(out->GetTlv(serbuffer, serialOffset, &deserialOffset)); + + /* again check sizes */ + EXPECT_TRUE(serialOffset == deserialOffset); + EXPECT_TRUE(deserialOffset == initsize); + EXPECT_TRUE(out->TlvSize() == initsize); + + str << "Class In/Serialised/Out!" << std::endl; + in->print(str, 0); + displayRawPacket(str, serbuffer, serialOffset); + out->print(str, 0); + return 1; +} + +/* This function checks the TLV header, and steps on to the next one + */ + +bool test_StepThroughTlvStack(std::ostream &str, void *data, int size) +{ + uint32_t offset = 0; + uint32_t index = 0; + while (offset + 4 <= size) + { + uint16_t tlvtype = GetTlvType( &(((uint8_t *) data)[offset]) ); + uint16_t tlvsize = GetTlvSize( &(((uint8_t *) data)[offset]) ); + str << "Tlv Entry[" << index << "] => Offset: " << offset; + str << " Type: " << tlvtype; + str << " Size: " << tlvsize; + str << std::endl; + + offset += tlvsize; + } + EXPECT_TRUE(offset == size); /* we match up exactly */ + return 1; +} + + +int test_CreateTlvStack(std::ostream &str, + std::vector items, void *data, uint32_t *totalsize) +{ + /* (1) select a random item + * (2) check size -> if okay serialise onto the end + * (3) loop!. + */ + uint32_t offset = 0; + uint32_t count = 0; + + while(1) + { + int idx = (int) (items.size() * (rand() / (RAND_MAX + 1.0))); + uint32_t tlvsize = items[idx] -> TlvSize(); + + if (offset + tlvsize > *totalsize) + { + *totalsize = offset; + return count; + } + + str << "Stack[" << count << "]"; + str << " Offset: " << offset; + str << " TlvSize: " << tlvsize; + str << std::endl; + + /* serialise it */ + items[idx] -> SetTlv(data, *totalsize, &offset); + items[idx] -> print(str, 10); + count++; + } + *totalsize = offset; + return 0; +} + +int test_TlvSet(std::vector items, int maxsize) +{ + int totalsize = maxsize; + void *data = malloc(totalsize); + uint32_t size = totalsize; + + test_CreateTlvStack(std::cerr, items, data, &size); + test_StepThroughTlvStack(std::cerr, data, size); + + return 1; +} + + diff --git a/tests/unittests/libretroshare/serialiser/rstlvutil.h b/tests/unittests/libretroshare/serialiser/rstlvutil.h new file mode 100644 index 000000000..910c494d3 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rstlvutil.h @@ -0,0 +1,48 @@ +#ifndef RS_TLV_UTIL_H +#define RS_TLV_UTIL_H + +/* + * libretroshare/src/serialiser: rstlvutil.h + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +/* some utility functions mainly for debugging + */ + +#include +#include +#include + +class RsTlvItem; + +/* print out a packet */ +void displayRawPacket(std::ostream &out, void *data, uint32_t size); +int test_SerialiseTlvItem(std::ostream &str, RsTlvItem *in, RsTlvItem *out); + + +bool test_StepThroughTlvStack(std::ostream &str, void *data, int size); +int test_CreateTlvStack(std::ostream &str, + std::vector items, void *data, int totalsize); +int test_TlvSet(std::vector items, int maxsize); + +#endif diff --git a/tests/unittests/libretroshare/serialiser/rsturtleitem_test.cc b/tests/unittests/libretroshare/serialiser/rsturtleitem_test.cc new file mode 100644 index 000000000..23157efe8 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/rsturtleitem_test.cc @@ -0,0 +1,249 @@ + +/* + * libretroshare/src/serialiser: rsturtleitems_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Cyril Soler + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +/****************************************************************** + */ +#include + +#include +#include +#include "turtle/rsturtleitem.h" +#include "ft/ftturtlefiletransferitem.h" + +#include "support.h" +#include "rstlvutil.h" + + +RsSerialType* init_item(CompressedChunkMap& map) +{ + map._map.clear() ; + for(uint32_t i=0;i<15;++i) + map._map.push_back(rand()) ; + + return new RsTurtleSerialiser(); +} +bool operator==(const CompressedChunkMap& m1,const CompressedChunkMap& m2) +{ + if(m1._map.size() != m2._map.size()) return false ; + + for(uint32_t i=0;i::const_iterator i1(it1.result.begin()) ; + std::list::const_iterator i2(it2.result.begin()) ; + + for(;i1!=it1.result.end() && i2!=it2.result.end();++i1,++i2) + if( !(*i1 == *i2)) + return false ; + + return true ; +} + +TEST(libretroshare_serialiser, RsTurtleItem) +{ + for(uint32_t i=0;i<20;++i) + { + //test_RsItem(); + //test_RsItem(); + //test_RsItem(); + //test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + test_RsItem(); + } +} + + diff --git a/tests/unittests/libretroshare/serialiser/support.cc b/tests/unittests/libretroshare/serialiser/support.cc new file mode 100644 index 000000000..4ba32ca4e --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/support.cc @@ -0,0 +1,328 @@ +/* + * libretroshare/src/serialiser: t_support.h.cc + * + * RetroShare Serialiser tests. + * + * Copyright 2007-2008 by Christopher Evi-Parker + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include "support.h" +#include "serialiser/rstlvbase.h" + +void randString(const uint32_t length, std::string& outStr) +{ + char alpha = 'a'; + char* stringData = NULL; + + stringData = new char[length]; + + for(uint32_t i=0; i != length; i++) + stringData[i] = alpha + (rand() % 26); + + outStr.assign(stringData, length); + delete[] stringData; + + return; +} + +void randString(const uint32_t length, std::wstring& outStr) +{ + wchar_t alpha = L'a'; + wchar_t* stringData = NULL; + + stringData = new wchar_t[length]; + + for(uint32_t i=0; i != length; i++) + stringData[i] = (alpha + (rand() % 26)); + + outStr.assign(stringData, length); + delete[] stringData; + + return; +} + + +void init_item(RsTlvSecurityKeySet& ks) +{ + int n = rand()%24; + randString(SHORT_STR, ks.groupId); + for(int i=1; i::const_iterator l_cit = l.keys.begin(), + r_cit = r.keys.begin(); + + for(; l_cit != l.keys.end(); l_cit++, r_cit++){ + if(l_cit->first != r_cit->first) return false; + if(!(l_cit->second == r_cit->second)) return false; + } + + return true; +} + + + +bool operator==(const RsTlvSecurityKey& sk1, const RsTlvSecurityKey& sk2) +{ + + if(sk1.startTS != sk2.startTS) return false; + if(sk1.endTS != sk2.endTS) return false; + if(sk1.keyFlags != sk2.keyFlags) return false; + if(sk1.keyId != sk2.keyId) return false; + if(!(sk1.keyData == sk1.keyData)) return false; + + return true; +} + +bool operator==(const RsTlvKeySignature& ks1, const RsTlvKeySignature& ks2) +{ + + if(ks1.keyId != ks2.keyId) return false; + if(!(ks1.signData == ks2.signData)) return false; + + return true; +} + +bool operator==(const RsTlvKeySignatureSet& kss1, const RsTlvKeySignatureSet& kss2) +{ + const std::map& set1 = kss1.keySignSet, + &set2 = kss2.keySignSet; + + if(set1.size() != set2.size()) return false; + + std::map::const_iterator it1 = set1.begin(), it2; + + for(; it1 != set1.end(); it1++) + { + SignType st1 = it1->first; + + if( (it2 =set2.find(st1)) == set2.end()) + return false; + + if(!(it1->second == it2->second)) + return false; + + } + + return true; +} + +bool operator==(const RsTlvPeerIdSet& pids1, const RsTlvPeerIdSet& pids2) +{ + std::list::const_iterator it1 = pids1.ids.begin(), + it2 = pids2.ids.begin(); + + + for(; ((it1 != pids1.ids.end()) && (it2 != pids2.ids.end())); it1++, it2++) + { + if(*it1 != *it2) return false; + } + + return true; + +} + + +void init_item(RsTlvImage& im) +{ + std::string imageData; + randString(LARGE_STR, imageData); + im.binData.setBinData(imageData.c_str(), imageData.size()); + im.image_type = RSTLV_IMAGE_TYPE_PNG; + + return; +} + +bool operator==(const RsTlvBinaryData& bd1, const RsTlvBinaryData& bd2) +{ + if(bd1.tlvtype != bd2.tlvtype) return false; + if(bd1.bin_len != bd2.bin_len) return false; + + unsigned char *bin1 = (unsigned char*)(bd1.bin_data), + *bin2 = (unsigned char*)(bd2.bin_data); + + for(uint32_t i=0; i < bd1.bin_len; bin1++, bin2++, i++) + { + if(*bin1 != *bin2) + return false; + } + + return true; +} + + +void init_item(RsTlvSecurityKey& sk) +{ + int randnum = rand()%313131; + + sk.endTS = randnum; + sk.keyFlags = randnum; + sk.startTS = randnum; + randString(SHORT_STR, sk.keyId); + + std::string randomStr; + randString(LARGE_STR, randomStr); + + sk.keyData.setBinData(randomStr.c_str(), randomStr.size()); + + return; +} + +void init_item(RsTlvKeySignature& ks) +{ + randString(SHORT_STR, ks.keyId); + + std::string signData; + randString(LARGE_STR, signData); + + ks.signData.setBinData(signData.c_str(), signData.size()); + + return; +} +void init_item(RsTlvKeySignatureSet &kss) +{ + int numSign = rand()%21; + + for(int i=0; i < numSign; i++) + { + RsTlvKeySignature sign; + SignType sType = rand()%2452; + init_item(sign); + kss.keySignSet.insert(std::make_pair(sType, sign)); + } +} + + +bool operator==(const RsTlvImage& img1, const RsTlvImage& img2) +{ + if(img1.image_type != img2.image_type) return false; + if(!(img1.binData == img2.binData)) return false; + + return true; + +} + +/** channels, forums and blogs **/ + +void init_item(RsTlvHashSet& hs) +{ + for(int i=0; i < 10; i++) + hs.ids.push_back(RsFileHash::random()); + + return; +} + +void init_item(RsTlvPeerIdSet& ps) +{ + for(int i=0; i < 10; i++) + ps.ids.push_back(RsPeerId::random()); + + return; +} + +bool operator==(const RsTlvHashSet& hs1,const RsTlvHashSet& hs2) +{ + std::list::const_iterator it1 = hs1.ids.begin(), + it2 = hs2.ids.begin(); + + for(; ((it1 != hs1.ids.end()) && (it2 != hs2.ids.end())); it1++, it2++) + { + if(*it1 != *it2) return false; + } + + return true; +} + +void init_item(RsTlvFileItem& fi) +{ + fi.age = rand()%200; + fi.filesize = rand()%34030313; + fi.hash = RsFileHash::random(); + randString(SHORT_STR, fi.name); + randString(SHORT_STR, fi.path); + fi.piecesize = rand()%232; + fi.pop = rand()%2354; + init_item(fi.hashset); + + 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); + randString(SHORT_STR, fSet.title); + RsTlvFileItem fi1, fi2; + init_item(fi1); + init_item(fi2); + fSet.items.push_back(fi1); + fSet.items.push_back(fi2); + + return; +} + +bool operator==(const RsTlvFileSet& fs1,const RsTlvFileSet& fs2) +{ + if(fs1.comment != fs2.comment) return false; + if(fs1.title != fs2.title) return false; + + std::list::const_iterator it1 = fs1.items.begin(), + it2 = fs2.items.begin(); + + for(; ((it1 != fs1.items.end()) && (it2 != fs2.items.end())); it1++, it2++) + if(!(*it1 == *it2)) return false; + + return true; +} + +bool operator==(const RsTlvFileItem& fi1,const RsTlvFileItem& fi2) +{ + if(fi1.age != fi2.age) return false; + if(fi1.filesize != fi2.filesize) return false; + if(fi1.hash != fi2.hash) return false; + if(!(fi1.hashset == fi2.hashset)) return false; + if(fi1.name != fi2.name) return false; + if(fi1.path != fi2.path) return false; + if(fi1.piecesize != fi2.piecesize) return false; + if(fi1.pop != fi2.pop) return false; + + return true; +} diff --git a/tests/unittests/libretroshare/serialiser/support.h b/tests/unittests/libretroshare/serialiser/support.h new file mode 100644 index 000000000..5841d22f5 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/support.h @@ -0,0 +1,246 @@ +#ifndef SUPPORT_H_ +#define SUPPORT_H_ + +/* + * libretroshare/src/tests/serialiser: + * + * RetroShare Serialiser tests. + * + * Copyright 2007-2008 by Christopher Evi-Parker, Cyril Soler + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include +#include +#include + +#include "serialiser/rsserial.h" +#include "serialiser/rstlvkeys.h" +#include "serialiser/rstlvbinary.h" +#include "serialiser/rstlvfileitem.h" +#include "serialiser/rstlvidset.h" +#include "serialiser/rstlvimage.h" + +#include "rstlvutil.h" + + +/** + * This contains functions that may be useful for testing throughout the + * retroshare's serialiser + * package, if you find a function you keep using everywhere, might be a good idea to add it here + */ + + +#define SHORT_STR 100 +#define LARGE_STR 1000 + +void randString(const uint32_t, std::string&); +void randString(const uint32_t, std::wstring&); + + +/* for testing compound tlv items */ + +void init_item(RsTlvSecurityKey&); +void init_item(RsTlvSecurityKeySet&); +void init_item(RsTlvKeySignature&); +void init_item(RsTlvKeySignatureSet&); +void init_item(RsTlvBinaryData&); +void init_item(RsTlvFileItem&); +void init_item(RsTlvFileSet&); +void init_item(RsTlvHashSet&); +void init_item(RsTlvPeerIdSet&); +void init_item(RsTlvImage&); +void init_item(RsTlvPeerIdSet&); + +bool operator==(const RsTlvSecurityKey&, const RsTlvSecurityKey& ); +bool operator==(const RsTlvSecurityKeySet&, const RsTlvSecurityKeySet& ); +bool operator==(const RsTlvKeySignature&, const RsTlvKeySignature& ); +bool operator==(const RsTlvBinaryData&, const RsTlvBinaryData&); +bool operator==(const RsTlvFileItem&, const RsTlvFileItem&); +bool operator==(const RsTlvFileSet&, const RsTlvFileSet& ); +bool operator==(const RsTlvHashSet&, const RsTlvHashSet&); +bool operator==(const RsTlvImage&, const RsTlvImage& ); +bool operator==(const RsTlvPeerIdSet& , const RsTlvPeerIdSet& ); +bool operator==(const RsTlvKeySignatureSet& , const RsTlvKeySignatureSet& ); + + + +/*! + * This templated test function which allows you to test + * retroshare serialiser items (except compound tlv items) + * you the function must implement a function + * + * 'RsSerialType* init_item(YourRsItem& rs_item)' + * which returns valid serialiser that + * can serialiser rs_item. You also need to implement an operator + * + * Also need to implement a function + * 'bool operator =(YourRsItem& rs_itemL, YourRsItem& rs_temR)' + * which allows this function to test for equality between both parameters. + * rs_temR is the result of deserialising the left operand (1st parameter). + * not YourRsItem in specifier in about functions should be a derived type from RsItem + * + * @param T the item you want to test + */ + +template int test_RsItem() +{ + /* make a serialisable RsTurtleItem */ + + RsSerialiser srl; + + /* initialise */ + T rsfi ; + RsSerialType *rsfis = init_item(rsfi) ; + + /* attempt to serialise it before we add it to the serialiser */ + + EXPECT_TRUE(0 == srl.size(&rsfi)); + + static const uint32_t MAX_BUFSIZE = 22000 ; + + char *buffer = new char[MAX_BUFSIZE]; + uint32_t sersize = MAX_BUFSIZE; + + EXPECT_TRUE(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); + + EXPECT_TRUE(done == true); + + uint32_t sersize2 = sersize; + RsItem *output = srl.deserialise((void *) buffer, &sersize2); + + EXPECT_TRUE(output != NULL); + if (!output) + { + return 1; + } + + EXPECT_TRUE(sersize2 == sersize); + + T *outfi = dynamic_cast(output); + + EXPECT_TRUE(outfi != NULL); + if (!outfi) + { + return 1; + } + + if(!(*outfi == rsfi)) + { + std::cerr << "Items differ: "<< std::endl; + outfi->print(std::cerr,0) ; + rsfi.print(std::cerr,0) ; + } + if (outfi) + EXPECT_TRUE(*outfi == rsfi) ; + + + sersize2 = MAX_BUFSIZE; + bool done2 = srl.serialise(outfi, (void *) &(buffer[16*8]), &sersize2); + + EXPECT_TRUE(done2) ; + EXPECT_TRUE(sersize2 == sersize); + +// displayRawPacket(std::cerr, (void *) buffer, 16 * 8 + sersize2); + + delete[] buffer ; + //delete rsfis; + + return 1; +} + +template int test_RsItem(uint16_t servtype) +{ + /* make a serialisable RsTurtleItem */ + + RsSerialiser srl; + + /* initialise */ + T rsfi(servtype) ; + RsSerialType *rsfis = init_item(rsfi) ; // deleted on destruction of srl + + /* attempt to serialise it before we add it to the serialiser */ + + EXPECT_TRUE(0 == srl.size(&rsfi)); + + static const uint32_t MAX_BUFSIZE = 22000 ; + + char *buffer = new char[MAX_BUFSIZE]; + uint32_t sersize = MAX_BUFSIZE; + + EXPECT_TRUE(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); + + EXPECT_TRUE(done == true); + + uint32_t sersize2 = sersize; + RsItem *output = srl.deserialise((void *) buffer, &sersize2); + + EXPECT_TRUE(output != NULL); + EXPECT_TRUE(sersize2 == sersize); + + T *outfi = dynamic_cast(output); + + EXPECT_TRUE(outfi != NULL); + + if (outfi) + EXPECT_TRUE(*outfi == rsfi) ; + + sersize2 = MAX_BUFSIZE; + bool done2 = srl.serialise(outfi, (void *) &(buffer[16*8]), &sersize2); + + EXPECT_TRUE(done2) ; + EXPECT_TRUE(sersize2 == sersize); + +// displayRawPacket(std::cerr, (void *) buffer, 16 * 8 + sersize2); + + delete[] buffer ; + + return 1; +} +#endif /* SUPPORT_H_ */ diff --git a/tests/unittests/libretroshare/serialiser/tlvbase_test.cc b/tests/unittests/libretroshare/serialiser/tlvbase_test.cc new file mode 100644 index 000000000..0dd6e839a --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/tlvbase_test.cc @@ -0,0 +1,172 @@ + +/* + * libretroshare/src/serialiser: tlvbase_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Horatio. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include +#include +#include +#include + +#include "serialiser/rstlvbase.h" +#include "util/rsnet.h" + +TEST(libretroshare_serialiser, test_RsTlvBase) +{ + //uint32_t array[] = {0x122, 0x234}; + char data[20]; + memset((void*)data, 65, sizeof(data)); // In ASCII 'A' =65 + + + std::string out; + + // First two bytes are type. + data[0]=0; + data[1]=0; + // Next 4 bytes is size. + data[2]=0; + data[3]=0; + data[4]=0; + data[5]=10; + uint32_t off =0; + GetTlvString((void*)data, 20, &off, 0, out); + + EXPECT_TRUE(out == "AAAA"); + + std::cout << "Output is : " << out << std::endl; + + uint16_t data2[] = {0, 0, 0x0300}; + + uint16_t t = GetTlvSize((void*) data2); + + + EXPECT_TRUE( t == ntohs(0x0300)); + + //std::cout << "GetTlvSize = " < + +#include +#include "serialiser/rstlvbase.h" +#include "rstlvutil.h" +#include "util/rsnet.h" + + +int test_OneString(std::string input, uint16_t type); + +TEST(libretroshare_serialiser, test_RsTlvString) +{ + std::string nullString; + std::string oneString = "1"; + std::string shortString = "ab cd"; + std::string longString = "abcd efgh ijkl mnop qrst uvw"; + + std::cerr << "test_RsTlvString() Testing" << std::endl; + test_OneString(nullString, 1234); + test_OneString(oneString, 12); + test_OneString(shortString, 79); + test_OneString(longString, 7654); +} + + +int test_OneString(std::string input, uint16_t type) +{ + /* an array to work from */ + char tlvdata[2048]; + std::string OutString; + + std::cerr << "test_OneString() Testing ... Print/Serialise/Deserialise"; + std::cerr << std::endl; + /* start with SetTlvString() */ + + uint16_t initsize = GetTlvStringSize(input); + uint32_t outOffset = 0; + uint32_t inOffset = 0; + + std::cerr << "Serialising: " << input << std::endl; + EXPECT_TRUE(SetTlvString((void*)tlvdata, 2048, &outOffset, type, input)); + std::cerr << "Init Size: " << initsize << std::endl; + std::cerr << "Serialised Size: " << outOffset << std::endl; + displayRawPacket(std::cerr, tlvdata, outOffset); + + EXPECT_TRUE(outOffset == initsize); /* check that the offset matches the size */ + + std::cerr << "DeSerialising" << std::endl; + + /* fails if type is wrong! */ + EXPECT_TRUE(0 == GetTlvString((void*)tlvdata, outOffset, &inOffset, type-1, OutString)); + EXPECT_TRUE(GetTlvString((void*)tlvdata, outOffset, &inOffset, type, OutString)); + + EXPECT_TRUE(initsize == inOffset); /* check that the offset matches the size */ + EXPECT_TRUE(input == OutString); /* check that strings match */ + std::cerr << "Deserialised: Size: " << inOffset << std::endl; + std::cerr << "Deserialised: String: " << OutString << std::endl; + + return 1; +} + +int test_IpAddr(struct sockaddr_in *addr, uint16_t type); + +TEST(libretroshare_serialiser, test_RsTlvIPAddr) +{ + struct sockaddr_in addr; + + inet_aton("10.0.0.111", &(addr.sin_addr)); + addr.sin_port = htons(1111); + + test_IpAddr(&addr, 1234); + + inet_aton("255.255.255.1", &(addr.sin_addr)); + addr.sin_port = htons(9999); + + test_IpAddr(&addr, 1234); + + inet_aton("128.255.255.1", &(addr.sin_addr)); + addr.sin_port = htons(1); + + test_IpAddr(&addr, 1234); +} + +int test_IpAddr(struct sockaddr_in *addr, uint16_t type) +{ + /* an array to work from */ + char tlvdata[2048]; + struct sockaddr_in outaddr; + + std::cerr << "test_IpAddr() Testing ... Print/Serialise/Deserialise"; + std::cerr << std::endl; + /* start with SetTlvString() */ + + uint16_t initsize = GetTlvIpAddrPortV4Size(); + uint32_t outOffset = 0; + uint32_t inOffset = 0; + + std::cerr << "Serialising IPAddr: " << inet_ntoa(addr->sin_addr) << std::endl; + std::cerr << " Port : " << ntohs(addr->sin_port) << std::endl; + + EXPECT_TRUE(SetTlvIpAddrPortV4((void*)tlvdata, 2048, &outOffset, type, addr)); + std::cerr << "Init Size: " << initsize << std::endl; + std::cerr << "Serialised Size: " << outOffset << std::endl; + displayRawPacket(std::cerr, tlvdata, outOffset); + + EXPECT_TRUE(outOffset == initsize); /* check that the offset matches the size */ + + std::cerr << "DeSerialising" << std::endl; + + /* fails if type is wrong! */ + EXPECT_TRUE(0 == GetTlvIpAddrPortV4((void*)tlvdata, outOffset, &inOffset, type-1, &outaddr)); + EXPECT_TRUE(GetTlvIpAddrPortV4((void*)tlvdata, outOffset, &inOffset, type, &outaddr)); + + EXPECT_TRUE(initsize == inOffset); /* check that the offset matches the size */ + EXPECT_TRUE(addr->sin_addr.s_addr == outaddr.sin_addr.s_addr); /* check that IP match */ + EXPECT_TRUE(addr->sin_port == outaddr.sin_port); /* check that Port match */ + std::cerr << "Deserialised: Size: " << inOffset << std::endl; + std::cerr << "Deserialised IPAddr: " << inet_ntoa(outaddr.sin_addr) << std::endl; + std::cerr << " Port : " << ntohs(outaddr.sin_port) << std::endl; + + return 1; +} + + + diff --git a/tests/unittests/libretroshare/serialiser/tlvitems_test.cc b/tests/unittests/libretroshare/serialiser/tlvitems_test.cc new file mode 100644 index 000000000..4204e4254 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/tlvitems_test.cc @@ -0,0 +1,66 @@ + +/* + * libretroshare/src/serialiser: tlvitems_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +/****************************************************************** + * tlvfileitem test. + * + * + */ +#include + +#include +#include +#include "serialiser/rstlvbinary.h" + +#include "rstlvutil.h" + +#define BIN_LEN 65536 /* bigger than 64k */ + +TEST(libretroshare_serialiser, test_RsTlvBinData2) +{ + RsTlvBinaryData d1(1023); + RsTlvBinaryData d2(1023); + + char data[BIN_LEN] = {0}; + int i, j; + for(i = 0; i < BIN_LEN; i++) + { + data[i] = i%13; + } + + for(j = 1; j < BIN_LEN; j *= 2) + { + d1.setBinData(data, j); + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &d1, &d2)); + + EXPECT_TRUE(d1.bin_len == d2.bin_len); + EXPECT_TRUE(0 == memcmp(d1.bin_data, d2.bin_data, d1.bin_len)); + } + +} + + + diff --git a/tests/unittests/libretroshare/serialiser/tlvkey_test.cc b/tests/unittests/libretroshare/serialiser/tlvkey_test.cc new file mode 100644 index 000000000..25d8b14ac --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/tlvkey_test.cc @@ -0,0 +1,24 @@ + +#include + +#include "support.h" +#include "serialiser/rstlvkeys.h" + +TEST(libretroshare_serialiser, test_RsTlvKeySignatureSet) +{ + RsTlvKeySignatureSet set; + + init_item(set); + + char data[set.TlvSize()]; + uint32_t offset = 0; + set.SetTlv(data, set.TlvSize(), &offset); + + RsTlvKeySignatureSet setConfirm; + + offset = 0; + setConfirm.GetTlv(data, set.TlvSize(), &offset); + + EXPECT_TRUE(setConfirm == set); + +} diff --git a/tests/unittests/libretroshare/serialiser/tlvrandom_test.cc b/tests/unittests/libretroshare/serialiser/tlvrandom_test.cc new file mode 100644 index 000000000..9449844c8 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/tlvrandom_test.cc @@ -0,0 +1,184 @@ + +/* + * libretroshare/src/serialiser: tlvrandom_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2009 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +/****************************************************************** + * tlvrandom_test. + * + * This test is designed to attempt to break the TLV serialiser. + * + * To do this we throw random data at the serialisers and try to decode it. + * As the serialiser will only attempt to deserialise if the tlvtype matches + * we cheat a little, and make this match - to increase to actual deserialise + * attempts. + * + * This test runs for 30 seconds and attempts to do as + * many deserialisation as possible. + */ + +#include + +#include +#include +#include +#include "serialiser/rstlvbase.h" +#include "serialiser/rstlvkeys.h" +#include "serialiser/rstlvbinary.h" +#include "serialiser/rstlvidset.h" +#include "serialiser/rstlvfileitem.h" +#include "serialiser/rstlvkeyvalue.h" +#include "serialiser/rstlvimage.h" +#include "rstlvutil.h" + +#define TEST_LENGTH 10 + + +#define BIN_LEN 523456 /* bigger than 64k */ + +bool test_TlvItem(RsTlvItem *item, void *data, uint32_t size, uint32_t offset); +bool test_SetTlvItem(RsTlvItem *item, uint16_t type, void *data, uint32_t size, uint32_t offset); + + +int test_TlvRandom(void *data, uint32_t len, uint32_t offset) +{ + uint32_t tmpoffset = 0; + + /* List of all the TLV types it could be! */ + RsTlvSecurityKey skey; + RsTlvSecurityKeySet skeyset; + RsTlvKeySignature keysign; + + RsTlvBinaryData bindata(TLV_TYPE_IMAGE); + + RsTlvFileItem fileitem; + RsTlvFileSet fileset; + RsTlvFileData filedata; + + RsTlvPeerIdSet peerset; + RsTlvServiceIdSet servset; + + RsTlvKeyValue kv; + RsTlvKeyValueSet kvset; + + RsTlvImage image; + + /* try to decode - with all types first */ + std::cerr << "test_TlvRandom:: Testing Files " << std::endl; + EXPECT_TRUE(test_TlvItem(&bindata, data, len, offset)); + EXPECT_TRUE(test_TlvItem(&fileitem, data, len, offset)); + EXPECT_TRUE(test_TlvItem(&fileset, data, len, offset)); + EXPECT_TRUE(test_TlvItem(&filedata, data, len, offset)); + std::cerr << "test_TlvRandom:: Testing Sets " << std::endl; + EXPECT_TRUE(test_TlvItem(&peerset, data, len, offset)); + EXPECT_TRUE(test_TlvItem(&servset, data, len, offset)); + EXPECT_TRUE(test_TlvItem(&kv, data, len, offset)); + EXPECT_TRUE(test_TlvItem(&kvset, data, len, offset)); + std::cerr << "test_TlvRandom:: Testing Keys " << std::endl; + EXPECT_TRUE(test_TlvItem(&skey, data, len, offset)); + EXPECT_TRUE(test_TlvItem(&skeyset, data, len, offset)); + EXPECT_TRUE(test_TlvItem(&keysign, data, len, offset)); + + /* now set the type correctly before decoding */ + std::cerr << "test_TlvRandom:: Testing Files (TYPESET)" << std::endl; + EXPECT_TRUE(test_SetTlvItem(&bindata, TLV_TYPE_IMAGE, data, len, offset)); + EXPECT_TRUE(test_SetTlvItem(&fileitem,TLV_TYPE_FILEITEM, data, len, offset)); + EXPECT_TRUE(test_SetTlvItem(&fileset, TLV_TYPE_FILESET, data, len, offset)); + EXPECT_TRUE(test_SetTlvItem(&filedata, TLV_TYPE_FILEDATA, data, len, offset)); + std::cerr << "test_TlvRandom:: Testing Sets (TYPESET)" << std::endl; + EXPECT_TRUE(test_SetTlvItem(&peerset, TLV_TYPE_PEERSET, data, len, offset)); + EXPECT_TRUE(test_SetTlvItem(&servset, TLV_TYPE_SERVICESET, data, len, offset)); + EXPECT_TRUE(test_SetTlvItem(&kv, TLV_TYPE_KEYVALUE, data, len, offset)); + EXPECT_TRUE(test_SetTlvItem(&kvset, TLV_TYPE_KEYVALUESET, data, len, offset)); + std::cerr << "test_TlvRandom:: Testing Keys (TYPESET)" << std::endl; + EXPECT_TRUE(test_SetTlvItem(&skey, TLV_TYPE_SECURITYKEY, data, len, offset)); + EXPECT_TRUE(test_SetTlvItem(&skeyset, TLV_TYPE_SECURITYKEYSET, data, len, offset)); + EXPECT_TRUE(test_SetTlvItem(&keysign, TLV_TYPE_KEYSIGNATURE, data, len, offset)); + + return 26; /* number of tests */ +} + +bool test_TlvItem(RsTlvItem *item, void *data, uint32_t size, uint32_t offset) +{ + uint32_t tmp_offset = offset; + if (item->GetTlv(data, size, &tmp_offset)) + { + std::cerr << "TLV decoded Random!"; + std::cerr << std::endl; + item->print(std::cerr, 20); + return false; + } + else + { + std::cerr << "TLV failed to decode"; + std::cerr << std::endl; + return true; + } +} + +bool test_SetTlvItem(RsTlvItem *item, uint16_t type, void *data, uint32_t size, uint32_t offset) +{ + /* set TLV type first! */ + void *typedata = (((uint8_t *) data) + offset); + SetTlvType(typedata, size - offset, type); + + return test_TlvItem(item, data, size, offset); +} + + +TEST(libretroshare_serialiser, test_RsTlvRandom) +{ + /* random data array to work through */ + uint32_t dsize = 100000; + uint32_t i; + uint8_t *data = (uint8_t *) malloc(dsize); + + if (!data) + { + std::cerr << "Failed to allocate array"; + std::cerr << std::endl; + exit(1); + } + + time_t startTs = time(NULL); + time_t endTs = startTs + TEST_LENGTH; + + srand(startTs); + for(i = 0; i < dsize; i++) + { + data[i] = rand() % 256; + } + + std::cerr << "TlvRandom Tests: setup data." << std::endl; + + int count = 0; + for(i = 0; endTs > time(NULL); i += 2) + { + uint32_t len = dsize - i; + count += test_TlvRandom(&(data[i]), len, i); + + std::cerr << "Run: " << count << " tests"; + std::cerr << std::endl; + } +} diff --git a/tests/unittests/libretroshare/serialiser/tlvstack_test.cc b/tests/unittests/libretroshare/serialiser/tlvstack_test.cc new file mode 100644 index 000000000..2abd661c9 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/tlvstack_test.cc @@ -0,0 +1,87 @@ + +/* + * libretroshare/src/serialiser: tlvstack_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Robert Fernie. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +/****************************************************************** + * tlvfileitem test. + * + * + */ + +#include + +#include +#include "serialiser/rstlvfileitem.h" +#include "serialiser/rstlvbinary.h" + +#include "rstlvutil.h" + +#define BIN_LEN 1024 + +TEST(libretroshare_serialiser, test_RsTlvStack) +{ + + /* now create a set of TLV items for the random generator */ + + RsTlvBinaryData *bd1 = new RsTlvBinaryData(123); + RsTlvBinaryData *bd2 = new RsTlvBinaryData(125); + + char data[BIN_LEN] = {0}; + int i; + for(i = 0; i < BIN_LEN; i++) + { + data[i] = i%13; + } + + bd1->setBinData(data, 5); + bd2->setBinData(data, 21); + + RsTlvFileItem *fi1 = new RsTlvFileItem(); + RsTlvFileItem *fi2 = new RsTlvFileItem(); + + /* initialise */ + fi1->filesize = 101010; + fi1->hash = "ABCDEFEGHE"; + fi1->name = "TestFile.txt"; + fi1->pop = 12; + fi1->age = 456; + + fi2->filesize = 101010; + fi2->hash = "ABCDEFEGHE"; + fi2->name = "TestFile.txt"; + fi2->pop = 0; + fi2->age = 0;; + + std::vector items; + items.resize(4); + items[0] = bd1; + items[1] = bd2; + items[2] = fi1; + items[3] = fi2; + + test_TlvSet(items, 1024); +} + + diff --git a/tests/unittests/libretroshare/serialiser/tlvtypes_test.cc b/tests/unittests/libretroshare/serialiser/tlvtypes_test.cc new file mode 100644 index 000000000..617daf6a6 --- /dev/null +++ b/tests/unittests/libretroshare/serialiser/tlvtypes_test.cc @@ -0,0 +1,303 @@ +/* + * libretroshare/src/serialiser: tlvfileitem_test.cc + * + * RetroShare Serialiser. + * + * Copyright 2007-2008 by Robert Fernie, Chris Evi-Parker + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License Version 2 as published by the Free Software Foundation. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA. + * + * Please report all bugs and problems to "retroshare@lunamutt.com". + * + */ + +#include + +#include +#include +#include "serialiser/rstlvbinary.h" +#include "serialiser/rstlvfileitem.h" +#include "serialiser/rstlvstring.h" +#include "serialiser/rstlvidset.h" +#include "serialiser/rstlvkeyvalue.h" +#include "serialiser/rstlvimage.h" +#include "serialiser/rstlvbase.h" + +#include "rstlvutil.h" + +#define RAND_SEED 1352534 + + +TEST(libretroshare_serialiser, test_RsTlvFileItem) +{ + RsTlvFileItem i1; + RsTlvFileItem i2; + + /* initialise */ + i1.filesize = 101010; + i1.hash = "ABCDEFEGHE"; + i1.name = "TestFile.txt"; + i1.pop = 12; + i1.age = 456; + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &i1, &i2)); + + /* check the data is the same */ + EXPECT_TRUE(i1.filesize == i2.filesize); + EXPECT_TRUE(i1.hash == i2.hash); + EXPECT_TRUE(i1.name == i2.name); + EXPECT_TRUE(i1.path == i2.path); + EXPECT_TRUE(i1.pop == i2.pop); + EXPECT_TRUE(i1.age == i2.age); + + /* do it again without optional data */ + i1.filesize = 123; + i1.name = ""; + i1.pop = 0; + i1.age = 0; + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &i1, &i2)); + + /* check the data is the same */ + EXPECT_TRUE(i1.filesize == i2.filesize); + EXPECT_TRUE(i1.hash == i2.hash); + EXPECT_TRUE(i1.name == i2.name); + EXPECT_TRUE(i1.path == i2.path); + EXPECT_TRUE(i1.pop == i2.pop); + EXPECT_TRUE(i1.age == i2.age); + + /* one more time - long file name, some optional data */ + i1.filesize = 123; + i1.name = "A Very Long File name that should fit in easily ??? with som $&%&^%* strange char (**$^%#&^$#*^%(&^ in there too!!!! ~~~!!$#(^$)$)(&%^)&\" oiyu thend"; + i1.pop = 666; + i1.age = 0; + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &i1, &i2)); + + /* check the data is the same */ + EXPECT_TRUE(i1.filesize == i2.filesize); + EXPECT_TRUE(i1.hash == i2.hash); + EXPECT_TRUE(i1.name == i2.name); + EXPECT_TRUE(i1.path == i2.path); + EXPECT_TRUE(i1.pop == i2.pop); + EXPECT_TRUE(i1.age == i2.age); +} + +TEST(libretroshare_serialiser, test_RsTlvFileSet) +{ + RsTlvFileSet s1; + RsTlvFileSet s2; + + int i = 0; + for(i = 0; i < 15; i++) + { + RsTlvFileItem fi; + fi.filesize = 16 + i * i; + fi.hash = "ABCDEF"; + std::ostringstream out; + out << "File" << i << "_inSet.txt"; + fi.name = out.str(); + if (i % 2 == 0) + { + fi.age = 10 * i; + } + else + { + fi.age = 0; + } + fi.pop = 0; + + s1.items.push_back(fi); + } + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &s1, &s2)); +} + + +TEST(libretroshare_serialiser, test_RsTlvFileData) +{ + RsTlvFileData d1; + RsTlvFileData d2; + + /* initialise */ + d1.file.filesize = 101010; + d1.file.hash = "ABCDEFEGHE"; + d1.file.name = ""; + d1.file.age = 0; + d1.file.pop = 0; + + char data[15]; + d1.binData.setBinData(data, 15); + + d1.file_offset = 222; + + EXPECT_TRUE(test_SerialiseTlvItem(std::cerr, &d1, &d2)); + + /* check the data is the same */ + EXPECT_TRUE(d1.file.filesize == d2.file.filesize); + EXPECT_TRUE(d1.file.hash == d2.file.hash); + EXPECT_TRUE(d1.file.name == d2.file.name); + EXPECT_TRUE(d1.file.path == d2.file.path); + EXPECT_TRUE(d1.file.pop == d2.file.pop); + EXPECT_TRUE(d1.file.age == d2.file.age); + + EXPECT_TRUE(d1.file_offset == d2.file_offset); + EXPECT_TRUE(d1.binData.bin_len == d2.binData.bin_len); +} + +TEST(libretroshare_serialiser, test_RsTlvPeerIdSet) +{ + + RsTlvPeerIdSet i1, i2; // one to set and other to get + + RsPeerId testId; + + std::string randString[5]; + randString[0] = "e$424!�!�"; + randString[1] = "e~:@L{L{KHKG"; + randString[2] = "e{@O**/*/*"; + randString[3] = "e?<HG�!�%$"; + randString[4] = "e>HG�!�%$"; + randString[4] = "e> + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} + + diff --git a/tests/unittests/unittests.pro b/tests/unittests/unittests.pro new file mode 100644 index 000000000..d8ab5b496 --- /dev/null +++ b/tests/unittests/unittests.pro @@ -0,0 +1,306 @@ +QT += network xml script +CONFIG += bitdht + +CONFIG += gxs debug + +LIBS += -lgtest + +gxs { + DEFINES += RS_ENABLE_GXS +} + +TEMPLATE = app +TARGET = unittests + +################################# Linux ########################################## +# Put lib dir in QMAKE_LFLAGS so it appears before -L/usr/lib +linux-* { + #CONFIG += version_detail_bash_script + QMAKE_CXXFLAGS *= -D_FILE_OFFSET_BITS=64 + + PRE_TARGETDEPS *= ../../libretroshare/src/lib/libretroshare.a + PRE_TARGETDEPS *= ../../openpgpsdk/src/lib/libops.a + + LIBS += ../../libretroshare/src/lib/libretroshare.a + LIBS += ../../openpgpsdk/src/lib/libops.a -lbz2 + LIBS += -lssl -lupnp -lixml -lXss -lgnome-keyring + LIBS *= -lcrypto -ldl -lX11 -lz + + gxs { + LIBS += ../../supportlibs/pegmarkdown/lib/libpegmarkdown.a + + # We need a explicit path here, to force using the home version of sqlite3 that really encrypts the database. + LIBS += ../../../lib/sqlcipher/.libs/libsqlcipher.a + } + + LIBS *= -lglib-2.0 + LIBS *= -rdynamic + DEFINES *= HAVE_XSS # for idle time, libx screensaver extensions + DEFINES *= UBUNTU +} + +linux-g++ { + OBJECTS_DIR = temp/linux-g++/obj +} + +linux-g++-64 { + OBJECTS_DIR = temp/linux-g++-64/obj +} + +#################### Cross compilation for windows under Linux ################### + +win32-x-g++ { + OBJECTS_DIR = temp/win32-x-g++/obj + + LIBS += ../../libretroshare/src/lib.win32xgcc/libretroshare.a + LIBS += ../../../../lib/win32-x-g++-v0.5/libssl.a + LIBS += ../../../../lib/win32-x-g++-v0.5/libcrypto.a + LIBS += ../../../../lib/win32-x-g++-v0.5/libgpgme.dll.a + LIBS += ../../../../lib/win32-x-g++-v0.5/libminiupnpc.a + LIBS += ../../../../lib/win32-x-g++-v0.5/libz.a + LIBS += -L${HOME}/.wine/drive_c/pthreads/lib -lpthreadGCE2 + LIBS += -lQtUiTools + LIBS += -lws2_32 -luuid -lole32 -liphlpapi -lcrypt32 -gdi32 + LIBS += -lole32 -lwinmm + + DEFINES *= WINDOWS_SYS WIN32 WIN32_CROSS_UBUNTU + + INCLUDEPATH += ../../../../gpgme-1.1.8/src/ + INCLUDEPATH += ../../../../libgpg-error-1.7/src/ + + RC_FILE = gui/images/retroshare_win.rc +} + +#################################### Windows ##################################### + +win32 { + # Switch on extra warnings + QMAKE_CFLAGS += -Wextra + QMAKE_CXXFLAGS += -Wextra + + # Switch off optimization for release version + QMAKE_CXXFLAGS_RELEASE -= -O2 + QMAKE_CXXFLAGS_RELEASE += -O0 + QMAKE_CFLAGS_RELEASE -= -O2 + QMAKE_CFLAGS_RELEASE += -O0 + + # Switch on optimization for debug version + #QMAKE_CXXFLAGS_DEBUG += -O2 + #QMAKE_CFLAGS_DEBUG += -O2 + + OBJECTS_DIR = temp/obj + #LIBS += -L"D/Qt/2009.03/qt/plugins/imageformats" + #QTPLUGIN += qjpeg + + PRE_TARGETDEPS *= ../../libretroshare/src/lib/libretroshare.a + PRE_TARGETDEPS *= ../../openpgpsdk/src/lib/libops.a + + LIBS += ../../libretroshare/src/lib/libretroshare.a + LIBS += ../../openpgpsdk/src/lib/libops.a -lbz2 + LIBS += -L"$$PWD/../../../lib" + + gxs { + LIBS += ../../supportlibs/pegmarkdown/lib/libpegmarkdown.a + LIBS += -lsqlcipher + } + + LIBS += -lssl -lcrypto -lpthread -lminiupnpc -lz +# added after bitdht +# LIBS += -lws2_32 + LIBS += -luuid -lole32 -liphlpapi -lcrypt32-cygwin -lgdi32 + LIBS += -lole32 -lwinmm + RC_FILE = gui/images/retroshare_win.rc + + # export symbols for the plugins + LIBS += -Wl,--export-all-symbols,--out-implib,lib/libretroshare-gui.a + + # create lib directory + QMAKE_PRE_LINK = $(CHK_DIR_EXISTS) lib $(MKDIR) lib + + DEFINES *= WINDOWS_SYS WIN32_LEAN_AND_MEAN _USE_32BIT_TIME_T + + INCLUDEPATH += . +} + +##################################### MacOS ###################################### + +macx { + # ENABLE THIS OPTION FOR Univeral Binary BUILD. + CONFIG += ppc x86 + QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.4 + + CONFIG += version_detail_bash_script + LIBS += ../../libretroshare/src/lib/libretroshare.a + LIBS += ../../openpgpsdk/src/lib/libops.a -lbz2 + LIBS += -lssl -lcrypto -lz + #LIBS += -lssl -lcrypto -lz -lgpgme -lgpg-error -lassuan + LIBS += ../../../miniupnpc-1.0/libminiupnpc.a + LIBS += -framework CoreFoundation + LIBS += -framework Security + + gxs { + LIBS += ../../supportlibs/pegmarkdown/lib/libpegmarkdown.a + + LIBS += ../../../lib/libsqlcipher.a + #LIBS += -lsqlite3 + + } + + + INCLUDEPATH += . + #DEFINES* = MAC_IDLE # for idle feature + CONFIG -= uitools + + +} + +##################################### FreeBSD ###################################### + +freebsd-* { + INCLUDEPATH *= /usr/local/include/gpgme + LIBS *= ../../libretroshare/src/lib/libretroshare.a + LIBS *= -lssl + LIBS *= -lgpgme + LIBS *= -lupnp + LIBS *= -lgnome-keyring + PRE_TARGETDEPS *= ../../libretroshare/src/lib/libretroshare.a + + gxs { + LIBS += ../../supportlibs/pegmarkdown/lib/libpegmarkdown.a + LIBS += -lsqlite3 + } + +} + +##################################### OpenBSD ###################################### + +openbsd-* { + INCLUDEPATH *= /usr/local/include + + PRE_TARGETDEPS *= ../../libretroshare/src/lib/libretroshare.a + PRE_TARGETDEPS *= ../../openpgpsdk/src/lib/libops.a + + LIBS *= ../../libretroshare/src/lib/libretroshare.a + LIBS *= ../../openpgpsdk/src/lib/libops.a -lbz2 + LIBS *= -lssl -lcrypto + LIBS *= -lgpgme + LIBS *= -lupnp + LIBS *= -lgnome-keyring + PRE_TARGETDEPS *= ../../libretroshare/src/lib/libretroshare.a + + gxs { + LIBS += ../../supportlibs/pegmarkdown/lib/libpegmarkdown.a + LIBS += -lsqlite3 + } + + LIBS *= -rdynamic +} + + + +############################## Common stuff ###################################### + +# On Linux systems that alredy have libssl and libcrypto it is advisable +# to rename the patched version of SSL to something like libsslxpgp.a and libcryptoxpg.a + +# ########################################### + +bitdht { + LIBS += ../../libbitdht/src/lib/libbitdht.a + PRE_TARGETDEPS *= ../../libbitdht/src/lib/libbitdht.a +} + +win32 { +# must be added after bitdht + LIBS += -lws2_32 +} + +DEPENDPATH += . \ + +INCLUDEPATH += ../../libretroshare/src/ + +# Input + + +# +# gui/channels/ChannelUserNotify.h \ +# gui/settings/ForumPage.h \ + +SOURCES += unittests.cc \ + +################################ Serialiser ################################ +HEADERS += libretroshare/serialiser/support.h \ + libretroshare/serialiser/rstlvutil.h \ + +SOURCES += libretroshare/serialiser/rsturtleitem_test.cc \ + libretroshare/serialiser/rsbaseitem_test.cc \ + libretroshare/serialiser/rsgxsupdateitem_test.cc \ + libretroshare/serialiser/rsmsgitem_test.cc \ + libretroshare/serialiser/rsstatusitem_test.cc \ + libretroshare/serialiser/rsnxsitems_test.cc \ + libretroshare/serialiser/rsgxsiditem_test.cc \ + libretroshare/serialiser/rsphotoitem_test.cc \ + libretroshare/serialiser/tlvbase_test2.cc \ + libretroshare/serialiser/tlvrandom_test.cc \ + libretroshare/serialiser/tlvbase_test.cc \ + libretroshare/serialiser/tlvstack_test.cc \ + libretroshare/serialiser/tlvitems_test.cc \ + libretroshare/serialiser/tlvtypes_test.cc \ + libretroshare/serialiser/tlvkey_test.cc \ + libretroshare/serialiser/support.cc \ + libretroshare/serialiser/rstlvutil.cc \ + +# Still to convert these. +# libretroshare/serialiser/rsconfigitem_test.cc \ +# libretroshare/serialiser/rsgrouteritem_test.cc \ + + +################################## GXS ##################################### + +HEADERS += libretroshare/gxs/common/data_support.h \ + +SOURCES += libretroshare/gxs/common/data_support.cc \ + +#HEADERS += libretroshare/gxs/nxs_test/nxstesthub.h \ +# libretroshare/gxs/nxs_test/nxstestscenario.h \ +# +#SOURCES += libretroshare/gxs/nxs_test/nxstesthub.cc \ +# libretroshare/gxs/nxs_test/nxstestscenario.cc \ +# libretroshare/gxs/nxs_test/rsgxsnetservice_test.cc \ + +HEADERS += libretroshare/gxs/gen_exchange/genexchangetester.h \ + libretroshare/gxs/gen_exchange/gxspublishmsgtest.h \ + libretroshare/gxs/gen_exchange/genexchangetestservice.h \ + libretroshare/gxs/gen_exchange/gxspublishgrouptest.h \ + libretroshare/gxs/gen_exchange/rsdummyservices.h \ + +# libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.h \ + +SOURCES += libretroshare/gxs/gen_exchange/gxspublishgrouptest.cc \ + libretroshare/gxs/gen_exchange/gxspublishmsgtest.cc \ + libretroshare/gxs/gen_exchange/rsdummyservices.cc \ + libretroshare/gxs/gen_exchange/rsgenexchange_test.cc \ + libretroshare/gxs/gen_exchange/genexchangetester.cc \ + libretroshare/gxs/gen_exchange/genexchangetestservice.cc \ + +# libretroshare/gxs/gen_exchange/gxsmsgrelatedtest.cc \ + +HEADERS += libretroshare/gxs/data_service/rsdataservice_test.h \ + +SOURCES += libretroshare/gxs/data_service/rsdataservice_test.cc \ + libretroshare/gxs/data_service/rsgxsdata_test.cc \ + + +################################ dbase ##################################### + +#HEADERS += libretroshare/dbase + +SOURCES += libretroshare/dbase/fisavetest.cc \ + libretroshare/dbase/fitest2.cc \ + libretroshare/dbase/searchtest.cc \ + +# libretroshare/dbase/ficachetest.cc \ +# libretroshare/dbase/fimontest.cc \ + + +