00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040 #ifdef HAVE_CONFIG_H
00041 # include <config.h>
00042 #endif
00043
00044 #ifdef ENABLE_INTEGRATION_TESTS
00045
00046 #include "ClientTest.h"
00047 #include "base/globalsdef.h"
00048 #include "base/test.h"
00049 #include "base/util/StringBuffer.h"
00050
00051 #include <memory>
00052 #include <vector>
00053 #include <utility>
00054 #include <sstream>
00055 #include <iomanip>
00056 #include <fstream>
00057 #include <iostream>
00058 #include <algorithm>
00059
00060 USE_NAMESPACE
00061
00062
00063 static std::list<std::string> listAnyItems(
00064 SyncSource *source,
00065 SyncItem * (SyncSource::*first)(),
00066 SyncItem * (SyncSource::*next)() )
00067 {
00068 SyncItem *item = NULL;
00069 std::list<std::string> res;
00070
00071 CPPUNIT_ASSERT(source);
00072 CPPUNIT_ASSERT(!source->getReport() || source->getReport()->getState() != SOURCE_ERROR);
00073 SOURCE_ASSERT_NO_FAILURE(source, item = (source->*first)());
00074 while ( item ) {
00075 const char *key = item->getKey();
00076 SOURCE_ASSERT(source, key);
00077 SOURCE_ASSERT(source, key[0]);
00078 res.push_back(key);
00079 delete item;
00080 SOURCE_ASSERT_NO_FAILURE(source, item = (source->*next)());
00081 }
00082
00083 return res;
00084 }
00085
00086 static std::list<std::string> listNewItems( SyncSource *source )
00087 {
00088 std::list<std::string> res = listAnyItems(
00089 source,
00090 &SyncSource::getFirstNewItem,
00091 &SyncSource::getNextNewItem );
00092 return res;
00093 }
00094
00095 static std::list<std::string> listUpdatedItems( SyncSource *source )
00096 {
00097 std::list<std::string> res = listAnyItems(
00098 source,
00099 &SyncSource::getFirstUpdatedItem,
00100 &SyncSource::getNextUpdatedItem );
00101 return res;
00102 }
00103
00104 static std::list<std::string> listDeletedItems( SyncSource *source )
00105 {
00106 std::list<std::string> res = listAnyItems(
00107 source,
00108 &SyncSource::getFirstDeletedItem,
00109 &SyncSource::getNextDeletedItem );
00110 return res;
00111 }
00112
00113 static std::list<std::string> listItems( SyncSource *source )
00114 {
00115 std::list<std::string> res = listAnyItems(
00116 source,
00117 &SyncSource::getFirstItem,
00118 &SyncSource::getNextItem );
00119 return res;
00120 }
00121
00122
00123 std::list<std::string> listItemsOfType(SyncSource *source, itemType type)
00124 {
00125 std::list<std::string> res;
00126
00127 switch(type) {
00128 case NEW_ITEMS:
00129 res = listNewItems(source);
00130 break;
00131 case UPDATED_ITEMS:
00132 res = listUpdatedItems(source);
00133 break;
00134 case DELETED_ITEMS:
00135 res = listDeletedItems(source);
00136 break;
00137 case TOTAL_ITEMS:
00138 res = listItems(source);
00139 break;
00140 default:
00141 CPPUNIT_ASSERT(false);
00142 break;
00143 }
00144 return res;
00145 }
00146
00147 static int countNewItems( SyncSource *source ) { return listNewItems(source).size(); }
00148 static int countUpdatedItems( SyncSource *source ) { return listUpdatedItems(source).size(); }
00149 static int countDeletedItems( SyncSource *source ) { return listDeletedItems(source).size(); }
00150 static int countItems( SyncSource *source ) { return listItems(source).size(); }
00151 int countItemsOfType(SyncSource *source, itemType type) { return listItemsOfType(source, type).size(); }
00152
00153
00154 static void importItem(SyncSource *source, std::string &data)
00155 {
00156 CPPUNIT_ASSERT(source);
00157 if (data.size()) {
00158 SyncItem item;
00159 item.setData( data.c_str(), (long)data.size() );
00160 item.setDataType( TEXT("raw") );
00161 int status = STC_OK;
00162 SOURCE_ASSERT_NO_FAILURE(source, status = source->addItem(item));
00163 CPPUNIT_ASSERT(status == STC_OK || status == STC_ITEM_ADDED);
00164 CPPUNIT_ASSERT(item.getKey() != 0);
00165 CPPUNIT_ASSERT(wcslen(item.getKey()) > 0);
00166 }
00167 }
00168
00169
00170 void LocalTests::addTests() {
00171 if (config.createSourceA) {
00172 ADD_TEST(LocalTests, testOpen);
00173 ADD_TEST(LocalTests, testIterateTwice);
00174 if (config.insertItem) {
00175 ADD_TEST(LocalTests, testSimpleInsert);
00176 ADD_TEST(LocalTests, testLocalDeleteAll);
00177 ADD_TEST(LocalTests, testComplexInsert);
00178
00179 if (config.updateItem) {
00180 ADD_TEST(LocalTests, testLocalUpdate);
00181
00182 if (config.createSourceB) {
00183 ADD_TEST(LocalTests, testChanges);
00184 }
00185 }
00186
00187 if (config.import &&
00188 config.dump &&
00189 config.compare &&
00190 config.testcases) {
00191 ADD_TEST(LocalTests, testImport);
00192 ADD_TEST(LocalTests, testImportDelete);
00193 }
00194
00195 if (config.templateItem &&
00196 config.uniqueProperties) {
00197 ADD_TEST(LocalTests, testManyChanges);
00198 }
00199
00200 if (config.parentItem &&
00201 config.childItem) {
00202 ADD_TEST(LocalTests, testLinkedItemsParent);
00203 ADD_TEST(LocalTests, testLinkedItemsChild);
00204 ADD_TEST(LocalTests, testLinkedItemsParentChild);
00205 ADD_TEST(LocalTests, testLinkedItemsChildParent);
00206 ADD_TEST(LocalTests, testLinkedItemsChildChangesParent);
00207 ADD_TEST(LocalTests, testLinkedItemsRemoveParentFirst);
00208 ADD_TEST(LocalTests, testLinkedItemsRemoveNormal);
00209 ADD_TEST(LocalTests, testLinkedItemsInsertParentTwice);
00210 ADD_TEST(LocalTests, testLinkedItemsInsertChildTwice);
00211 ADD_TEST(LocalTests, testLinkedItemsParentUpdate);
00212 ADD_TEST(LocalTests, testLinkedItemsUpdateChild);
00213 ADD_TEST(LocalTests, testLinkedItemsInsertBothUpdateChild);
00214 ADD_TEST(LocalTests, testLinkedItemsInsertBothUpdateParent);
00215 }
00216 }
00217 }
00218 }
00219
00220 std::string LocalTests::insert(CreateSource createSource, const char *data, bool relaxed) {
00221 std::string uid;
00222
00223
00224 std::auto_ptr<SyncSource> source(createSource());
00225 CPPUNIT_ASSERT(source.get() != 0);
00226
00227
00228 SOURCE_ASSERT(source.get(), source->beginSync() == 0);
00229 int numItems = 0;
00230 CPPUNIT_ASSERT_NO_THROW(numItems = countItems(source.get()));
00231 SyncItem item;
00232 item.setData(data, (long)strlen(data));
00233 int status = STC_OK;
00234 SOURCE_ASSERT_NO_FAILURE(source.get(), status = source->addItem(item));
00235 CPPUNIT_ASSERT(item.getKey() != 0);
00236 CPPUNIT_ASSERT(wcslen(item.getKey()) > 0);
00237 uid = item.getKey();
00238 SOURCE_ASSERT(source.get(), source->endSync() == 0);
00239
00240
00241 CPPUNIT_ASSERT_NO_THROW(source.reset());
00242
00243 if (!relaxed) {
00244
00245
00246
00247 CPPUNIT_ASSERT_NO_THROW(source.reset(createSource()));
00248 CPPUNIT_ASSERT(source.get() != 0);
00249 SOURCE_ASSERT(source.get(), source->beginSync() == 0);
00250 CPPUNIT_ASSERT(status == STC_OK || status == STC_ITEM_ADDED || status == STC_CONFLICT_RESOLVED_WITH_MERGE);
00251 CPPUNIT_ASSERT_EQUAL(numItems + (status == STC_CONFLICT_RESOLVED_WITH_MERGE ? 0 : 1),
00252 countItems(source.get()));
00253 CPPUNIT_ASSERT(countNewItems(source.get()) == 0);
00254 CPPUNIT_ASSERT(countUpdatedItems(source.get()) == 0);
00255 CPPUNIT_ASSERT(countDeletedItems(source.get()) == 0);
00256 SOURCE_ASSERT(source.get(), source->endSync() == 0 );
00257 CPPUNIT_ASSERT_NO_THROW(source.reset());
00258 }
00259
00260 #if 0
00261
00262 SyncItem *sameItem;
00263 SOURCE_ASSERT_NO_FAILURE(
00264 source,
00265 sameItem = source.createItem(item.getKey(), item.getState()));
00266 CPPUNIT_ASSERT(sameItem != 0);
00267 CPPUNIT_ASSERT(!strcmp( sameItem->getKey(), item.getKey()));
00268 delete sameItem;
00269 #endif
00270
00271 return uid;
00272 }
00273
00274
00275 static std::string updateItem(CreateSource createSource, const std::string &uid, const char *data) {
00276 std::string newuid;
00277
00278 CPPUNIT_ASSERT(createSource.createSource);
00279
00280
00281 std::auto_ptr<SyncSource> source(createSource());
00282 CPPUNIT_ASSERT(source.get() != 0);
00283 SOURCE_ASSERT(source.get(), source->beginSync() == 0);
00284
00285
00286 SyncItem item;
00287 item.setKey(uid.c_str());
00288 item.setData(data, (long)strlen(data) + 1);
00289 item.setDataType(TEXT(""));
00290 SOURCE_ASSERT_EQUAL(source.get(), (int)STC_OK, source->updateItem(item));
00291 SOURCE_ASSERT(source.get(), item.getKey());
00292 newuid = item.getKey();
00293
00294 SOURCE_ASSERT(source.get(), source->endSync() == 0);
00295 CPPUNIT_ASSERT_NO_THROW(source.reset());
00296
00297 return newuid;
00298 }
00299
00300
00301
00302
00303
00304
00305
00306 void LocalTests::update(CreateSource createSource, const char *data, bool check) {
00307 CPPUNIT_ASSERT(createSource.createSource);
00308 CPPUNIT_ASSERT(data);
00309
00310
00311 std::auto_ptr<SyncSource> source(createSource());
00312 CPPUNIT_ASSERT(source.get() != 0);
00313 SOURCE_ASSERT(source.get(), source->beginSync() == 0);
00314
00315
00316 SOURCE_ASSERT(source.get(), source->beginSync() == 0 );
00317 std::auto_ptr<SyncItem> item;
00318 SOURCE_ASSERT_NO_FAILURE(source.get(), item.reset(source->getFirstItem()) );
00319 CPPUNIT_ASSERT(item.get());
00320 item->setData(data, (long)strlen(data) + 1);
00321 item->setDataType(TEXT(""));
00322 SOURCE_ASSERT_EQUAL(source.get(), (int)STC_OK, source->updateItem(*item));
00323 SOURCE_ASSERT(source.get(), source->endSync() == 0);
00324 CPPUNIT_ASSERT_NO_THROW(source.reset());
00325
00326 if (!check) {
00327 return;
00328 }
00329
00330
00331 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
00332 SOURCE_ASSERT(source.get(), source->beginSync() == 0 );
00333 CPPUNIT_ASSERT_EQUAL(1, countItems(source.get()));
00334 CPPUNIT_ASSERT_EQUAL(0, countNewItems(source.get()));
00335 CPPUNIT_ASSERT_EQUAL(0, countUpdatedItems(source.get()));
00336 CPPUNIT_ASSERT_EQUAL(0, countDeletedItems(source.get()));
00337 std::auto_ptr<SyncItem> modifiedItem;
00338 SOURCE_ASSERT_NO_FAILURE(source.get(), modifiedItem.reset(source->getFirstItem()) );
00339 CPPUNIT_ASSERT(modifiedItem.get());
00340 CPPUNIT_ASSERT( wcslen( item->getKey() ) );
00341 CPPUNIT_ASSERT( !wcscmp( item->getKey(), modifiedItem->getKey() ) );
00342 }
00343
00344
00345 void LocalTests::deleteAll(CreateSource createSource) {
00346 CPPUNIT_ASSERT(createSource.createSource);
00347
00348
00349 std::auto_ptr<SyncSource> source(createSource());
00350 CPPUNIT_ASSERT(source.get() != 0);
00351 SOURCE_ASSERT(source.get(), source->beginSync() == 0);
00352
00353
00354 SOURCE_ASSERT_NO_FAILURE(source.get(), source->removeAllItems());
00355 SOURCE_ASSERT(source.get(), source->endSync() == 0);
00356 CPPUNIT_ASSERT_NO_THROW(source.reset());
00357
00358
00359 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSource()));
00360 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00361 SOURCE_ASSERT_MESSAGE(
00362 "should be empty now",
00363 source.get(),
00364 countItems(source.get()) == 0);
00365 CPPUNIT_ASSERT_EQUAL( 0, countNewItems(source.get()) );
00366 CPPUNIT_ASSERT_EQUAL( 0, countUpdatedItems(source.get()) );
00367 CPPUNIT_ASSERT_EQUAL( 0, countDeletedItems(source.get()) );
00368 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00369 CPPUNIT_ASSERT_NO_THROW(source.reset());
00370 }
00371
00372
00373 static void deleteItem(CreateSource createSource, const std::string &uid) {
00374 CPPUNIT_ASSERT(createSource.createSource);
00375
00376
00377 std::auto_ptr<SyncSource> source(createSource());
00378 CPPUNIT_ASSERT(source.get() != 0);
00379 SOURCE_ASSERT(source.get(), source->beginSync() == 0);
00380
00381
00382 SyncItem item;
00383 item.setKey(uid.c_str());
00384 SOURCE_ASSERT_EQUAL(source.get(), (int)STC_OK, source->deleteItem(item));
00385
00386 SOURCE_ASSERT(source.get(), source->endSync() == 0);
00387 CPPUNIT_ASSERT_NO_THROW(source.reset());
00388 }
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398 void LocalTests::compareDatabases(const char *refFile, SyncSource ©, bool raiseAssert) {
00399 CPPUNIT_ASSERT(config.dump);
00400
00401 std::string sourceFile, copyFile;
00402
00403 if (refFile) {
00404 sourceFile = refFile;
00405 } else {
00406 sourceFile = getCurrentTest() + ".source.test.dat";
00407 simplifyFilename(sourceFile);
00408 std::auto_ptr<SyncSource> source;
00409 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
00410 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00411 SOURCE_ASSERT_EQUAL(source.get(), 0, config.dump(client, *source.get(), sourceFile.c_str()));
00412 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00413 CPPUNIT_ASSERT_NO_THROW(source.reset());
00414 }
00415
00416 copyFile = getCurrentTest() + ".copy.test.dat";
00417 simplifyFilename(copyFile);
00418 SOURCE_ASSERT_EQUAL(©, 0, copy.beginSync());
00419 SOURCE_ASSERT_EQUAL(©, 0, config.dump(client, copy, copyFile.c_str()));
00420 SOURCE_ASSERT_EQUAL(©, 0, copy.endSync());
00421
00422 CPPUNIT_ASSERT(config.compare(client, sourceFile.c_str(), copyFile.c_str()));
00423 }
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435 int LocalTests::insertManyItems(CreateSource createSource, int startIndex, int numItems, int size) {
00436 CPPUNIT_ASSERT(config.templateItem);
00437 CPPUNIT_ASSERT(config.uniqueProperties);
00438
00439 std::auto_ptr<SyncSource> source;
00440 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
00441 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00442 CPPUNIT_ASSERT(startIndex > 1 || !countItems(source.get()));
00443
00444 int firstIndex = startIndex;
00445 if (firstIndex < 0) {
00446 firstIndex = 1;
00447 }
00448 int lastIndex = firstIndex + (numItems >= 1 ? numItems : config.numItems) - 1;
00449 for (int item = firstIndex; item <= lastIndex; item++) {
00450 std::string data = config.templateItem;
00451 std::stringstream prefix;
00452
00453 prefix << std::setfill('0') << std::setw(3) << item << " ";
00454
00455
00456 const char *prop = config.uniqueProperties;
00457 const char *nextProp;
00458 while (*prop) {
00459 std::string curProp;
00460 nextProp = strchr(prop, ':');
00461 if (!nextProp) {
00462 curProp = prop;
00463 } else {
00464 curProp = std::string(prop, 0, nextProp - prop);
00465 }
00466
00467 std::string property;
00468
00469
00470 property = "\n";
00471 property += curProp;
00472 property += ":";
00473 size_t off = data.find(property);
00474 if (off != data.npos) {
00475 data.insert(off + property.size(), prefix.str());
00476 }
00477
00478 if (!nextProp) {
00479 break;
00480 }
00481 prop = nextProp + 1;
00482 }
00483 if (size > 0 && (int)data.size() < size) {
00484 int additionalBytes = size - (int)data.size();
00485 int added = 0;
00486
00487 bool quoted = data.find("VERSION:1.0") != data.npos ||
00488 data.find("VERSION:2.1") != data.npos;
00489 size_t toreplace = 1;
00490
00491 CPPUNIT_ASSERT(config.sizeProperty);
00492
00493
00494 size_t off = data.find(config.sizeProperty);
00495 CPPUNIT_ASSERT(off != data.npos);
00496 std::stringstream stuffing;
00497 if (quoted) {
00498 stuffing << ";ENCODING=QUOTED-PRINTABLE:";
00499 } else {
00500 stuffing << ":";
00501 }
00502
00503
00504 if (data.find("BEGIN:VJOURNAL") != data.npos) {
00505 size_t start = data.find(":", off);
00506 CPPUNIT_ASSERT( start != data.npos );
00507 size_t eol = data.find("\\n", off);
00508 CPPUNIT_ASSERT( eol != data.npos );
00509 stuffing << data.substr(start + 1, eol - start + 1);
00510 toreplace += eol - start + 1;
00511 }
00512
00513 while(added < additionalBytes) {
00514 int linelen = 0;
00515
00516 while(added + 4 < additionalBytes &&
00517 linelen < 60) {
00518 stuffing << 'x';
00519 added++;
00520 linelen++;
00521 }
00522
00523 if (quoted) {
00524 stuffing << "x=0D=0Ax";
00525 added += 8;
00526 } else {
00527 stuffing << "x\\nx";
00528 added += 4;
00529 }
00530 }
00531 off = data.find(":", off);
00532 data.replace(off, toreplace, stuffing.str());
00533 }
00534
00535 importItem(source.get(), data);
00536 data = "";
00537 }
00538
00539 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00540 CPPUNIT_ASSERT_NO_THROW(source.reset());
00541 return lastIndex - firstIndex + 1;
00542 }
00543
00544
00545 void LocalTests::testOpen() {
00546
00547 CPPUNIT_ASSERT(config.createSourceA);
00548
00549 std::auto_ptr<SyncSource> source(createSourceA());
00550 CPPUNIT_ASSERT(source.get() != 0);
00551 CPPUNIT_ASSERT_NO_THROW(source.reset());
00552 }
00553
00554
00555 void LocalTests::testIterateTwice() {
00556
00557 CPPUNIT_ASSERT(config.createSourceA);
00558
00559
00560 std::auto_ptr<SyncSource> source(createSourceA());
00561 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00562 SOURCE_ASSERT_MESSAGE(
00563 "iterating twice should produce identical results",
00564 source.get(),
00565 countItems(source.get()) == countItems(source.get()));
00566 }
00567
00568
00569 void LocalTests::testSimpleInsert() {
00570
00571 CPPUNIT_ASSERT(config.insertItem);
00572 CPPUNIT_ASSERT(config.createSourceA);
00573
00574 insert(createSourceA, config.insertItem);
00575 }
00576
00577
00578 void LocalTests::testLocalDeleteAll() {
00579
00580 CPPUNIT_ASSERT(config.insertItem);
00581 CPPUNIT_ASSERT(config.createSourceA);
00582
00583
00584 insert(createSourceA, config.insertItem);
00585 deleteAll(createSourceA);
00586 }
00587
00588
00589 void LocalTests::testComplexInsert() {
00590 testLocalDeleteAll();
00591 testSimpleInsert();
00592 testIterateTwice();
00593 }
00594
00595
00596 void LocalTests::testLocalUpdate() {
00597
00598 CPPUNIT_ASSERT(config.updateItem);
00599
00600 testLocalDeleteAll();
00601 testSimpleInsert();
00602 update(createSourceA, config.updateItem);
00603 }
00604
00605
00606 void LocalTests::testChanges() {
00607
00608 CPPUNIT_ASSERT(config.createSourceB);
00609
00610 testLocalDeleteAll();
00611 testSimpleInsert();
00612
00613
00614 std::auto_ptr<SyncSource> source;
00615 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00616 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00617 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00618 CPPUNIT_ASSERT_NO_THROW(source.reset());
00619
00620
00621 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00622 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00623 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
00624 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
00625 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
00626 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
00627 std::auto_ptr<SyncItem> item;
00628 SOURCE_ASSERT_NO_FAILURE(source.get(), item.reset(source->getFirstItem()));
00629 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00630 CPPUNIT_ASSERT_NO_THROW(source.reset());
00631
00632
00633 deleteAll(createSourceA);
00634 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00635 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00636 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
00637 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
00638 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
00639 SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
00640 std::auto_ptr<SyncItem> deletedItem;
00641 SOURCE_ASSERT_NO_FAILURE(source.get(), deletedItem.reset(source->getFirstDeletedItem()));
00642 CPPUNIT_ASSERT( wcslen( item->getKey() ) );
00643 CPPUNIT_ASSERT( wcslen( deletedItem->getKey() ) );
00644 CPPUNIT_ASSERT( !wcscmp( item->getKey(), deletedItem->getKey() ) );
00645 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00646 CPPUNIT_ASSERT_NO_THROW(source.reset());
00647
00648
00649 testSimpleInsert();
00650 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00651 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00652 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
00653 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
00654 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
00655 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
00656 SOURCE_ASSERT_NO_FAILURE(source.get(), item.reset(source->getFirstItem()));
00657 std::auto_ptr<SyncItem> newItem;
00658 SOURCE_ASSERT_NO_FAILURE(source.get(), newItem.reset(source->getFirstNewItem()));
00659 CPPUNIT_ASSERT( wcslen( item->getKey() ) );
00660 CPPUNIT_ASSERT( wcslen( newItem->getKey() ) );
00661 CPPUNIT_ASSERT( !wcscmp( item->getKey(), newItem->getKey() ) );
00662 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00663 CPPUNIT_ASSERT_NO_THROW(source.reset());
00664
00665
00666 update(createSourceA, config.updateItem);
00667 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00668 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00669 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
00670 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
00671 SOURCE_ASSERT_EQUAL(source.get(), 1, countUpdatedItems(source.get()));
00672 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
00673 std::auto_ptr<SyncItem> updatedItem;
00674 SOURCE_ASSERT_NO_FAILURE(source.get(), updatedItem.reset(source->getFirstUpdatedItem()));
00675 CPPUNIT_ASSERT( wcslen( item->getKey() ) );
00676 CPPUNIT_ASSERT( wcslen( updatedItem->getKey() ) );
00677 CPPUNIT_ASSERT( !wcscmp( item->getKey(), updatedItem->getKey() ) );
00678 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00679 CPPUNIT_ASSERT_NO_THROW(source.reset());
00680
00681
00682
00683 deleteAll(createSourceA);
00684 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00685 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00686 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00687 testSimpleInsert();
00688 update(createSourceA, config.updateItem);
00689 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00690 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00691 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
00692 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()) + countUpdatedItems(source.get()));
00693 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
00694
00695
00696
00697 deleteAll(createSourceA);
00698 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00699 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00700 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00701 testSimpleInsert();
00702 deleteAll(createSourceA);
00703 testSimpleInsert();
00704 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceB()));
00705 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00706 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
00707 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()) + countUpdatedItems(source.get()));
00708 if (countDeletedItems(source.get()) == 1) {
00709
00710
00711
00712 SyncItem *deleted = source->getFirstDeletedItem();
00713 CPPUNIT_ASSERT(deleted);
00714 SyncItem *new_or_updated = source->getFirstNewItem();
00715 if (!new_or_updated) {
00716 new_or_updated = source->getFirstUpdatedItem();
00717 }
00718 CPPUNIT_ASSERT(new_or_updated);
00719 CPPUNIT_ASSERT(wcscmp(deleted->getKey(), new_or_updated->getKey()));
00720 } else {
00721 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
00722 }
00723 }
00724
00725
00726 void LocalTests::testImport() {
00727
00728 CPPUNIT_ASSERT(config.import);
00729 CPPUNIT_ASSERT(config.dump);
00730 CPPUNIT_ASSERT(config.compare);
00731 CPPUNIT_ASSERT(config.testcases);
00732
00733 testLocalDeleteAll();
00734
00735
00736 std::auto_ptr<SyncSource> source;
00737 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(createSourceA()));
00738 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
00739 SOURCE_ASSERT_EQUAL(source.get(), 0, config.import(client, *source.get(), config.testcases));
00740 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
00741 CPPUNIT_ASSERT_NO_THROW(source.reset());
00742
00743
00744 std::auto_ptr<SyncSource> copy;
00745 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceA()));
00746 compareDatabases(config.testcases, *copy.get());
00747 CPPUNIT_ASSERT_NO_THROW(source.reset());
00748 }
00749
00750
00751 void LocalTests::testImportDelete() {
00752 testImport();
00753
00754
00755
00756 testLocalDeleteAll();
00757 }
00758
00759
00760 void LocalTests::testManyChanges() {
00761
00762 CPPUNIT_ASSERT(config.templateItem);
00763 CPPUNIT_ASSERT(config.uniqueProperties);
00764
00765 deleteAll(createSourceA);
00766
00767
00768 std::auto_ptr<SyncSource> copy;
00769 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00770 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00771 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00772 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00773 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00774
00775
00776 int numItems = insertManyItems(createSourceA);
00777
00778
00779 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00780 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00781 SOURCE_ASSERT_EQUAL(copy.get(), numItems, countItems(copy.get()));
00782 SOURCE_ASSERT_EQUAL(copy.get(), numItems, countNewItems(copy.get()));
00783 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00784 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
00785 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00786 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00787
00788
00789 deleteAll(createSourceA);
00790
00791
00792 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00793 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00794 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00795 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
00796 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00797 SOURCE_ASSERT_EQUAL(copy.get(), numItems, countDeletedItems(copy.get()));
00798 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00799 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00800 }
00801
00802 template<class T, class V> int countEqual(const T &container,
00803 const V &value) {
00804 return count(container.begin(),
00805 container.end(),
00806 value);
00807 }
00808
00809
00810
00811 void LocalTests::testLinkedItemsParent() {
00812
00813 CPPUNIT_ASSERT(config.parentItem);
00814 CPPUNIT_ASSERT(config.childItem);
00815
00816 deleteAll(createSourceA);
00817 std::string parent, child;
00818 std::auto_ptr<SyncSource> copy;
00819
00820
00821 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00822 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00823 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00824 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00825 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00826
00827
00828 parent = insert(createSourceA, config.parentItem);
00829
00830
00831 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00832 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00833 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
00834 SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
00835 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00836 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
00837 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
00838 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00839 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00840
00841
00842 deleteAll(createSourceA);
00843
00844
00845 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00846 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00847 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00848 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
00849 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00850 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
00851 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
00852 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00853 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00854 }
00855
00856
00857
00858 void LocalTests::testLinkedItemsChild() {
00859 #if LINKED_ITEMS_RELAXED_SEMANTIC
00860
00861 CPPUNIT_ASSERT(config.parentItem);
00862 CPPUNIT_ASSERT(config.childItem);
00863
00864 deleteAll(createSourceA);
00865 std::string parent, child;
00866 std::auto_ptr<SyncSource> copy;
00867
00868
00869 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00870 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00871 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00872 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00873 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00874
00875
00876 child = insert(createSourceA, config.childItem);
00877
00878 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00879 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00880 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
00881 SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
00882 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00883 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
00884 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
00885 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00886 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00887
00888 deleteAll(createSourceA);
00889
00890 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00891 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00892 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00893 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
00894 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00895 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
00896 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
00897 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00898 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00899 #endif
00900 }
00901
00902
00903
00904 void LocalTests::testLinkedItemsParentChild() {
00905
00906 CPPUNIT_ASSERT(config.parentItem);
00907 CPPUNIT_ASSERT(config.childItem);
00908
00909 deleteAll(createSourceA);
00910 std::string parent, child;
00911 std::auto_ptr<SyncSource> copy;
00912
00913
00914 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00915 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00916 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00917 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00918 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00919
00920
00921 parent = insert(createSourceA, config.parentItem);
00922 child = insert(createSourceA, config.childItem);
00923
00924 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00925 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00926 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
00927 SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
00928 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00929 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
00930 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
00931 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
00932 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00933 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00934
00935 deleteAll(createSourceA);
00936
00937 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00938 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00939 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00940 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
00941 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00942 SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
00943 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
00944 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
00945 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00946 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00947 }
00948
00949
00950
00951 void LocalTests::testLinkedItemsChildParent() {
00952 #if LINKED_ITEMS_RELAXED_SEMANTIC
00953
00954 CPPUNIT_ASSERT(config.parentItem);
00955 CPPUNIT_ASSERT(config.childItem);
00956
00957 deleteAll(createSourceA);
00958 std::string parent, child;
00959 std::auto_ptr<SyncSource> copy;
00960
00961
00962 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00963 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00964 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00965 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00966 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00967
00968
00969 child = insert(createSourceA, config.childItem);
00970 parent = insert(createSourceA, config.parentItem, true);
00971
00972 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00973 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00974 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
00975 SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
00976 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00977 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
00978 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
00979 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
00980 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00981 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00982
00983 deleteAll(createSourceA);
00984
00985 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
00986 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
00987 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
00988 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
00989 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
00990 SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
00991 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
00992 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
00993 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
00994 CPPUNIT_ASSERT_NO_THROW(copy.reset());
00995 #endif
00996 }
00997
00998
00999
01000 void LocalTests::testLinkedItemsChildChangesParent() {
01001 #if LINKED_ITEMS_RELAXED_SEMANTIC
01002
01003 CPPUNIT_ASSERT(config.parentItem);
01004 CPPUNIT_ASSERT(config.childItem);
01005
01006 deleteAll(createSourceA);
01007 std::string parent, child;
01008 std::auto_ptr<SyncSource> copy;
01009
01010
01011 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01012 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01013 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01014 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01015 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01016
01017
01018 child = insert(createSourceA, config.childItem);
01019
01020 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01021 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01022 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01023 SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
01024 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01025 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01026 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
01027 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01028 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01029
01030 parent = insert(createSourceA, config.parentItem, true);
01031
01032 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01033 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01034 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
01035 SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
01036 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listNewItems(copy.get()), parent));
01037
01038
01039 SOURCE_ASSERT(copy.get(), 1 >= countUpdatedItems(copy.get()));
01040 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01041 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
01042 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
01043 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01044 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01045
01046 deleteAll(createSourceA);
01047
01048 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01049 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01050 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01051 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01052 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01053 SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
01054 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
01055 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
01056 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01057 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01058 #endif
01059 }
01060
01061
01062
01063 void LocalTests::testLinkedItemsRemoveParentFirst() {
01064 #if LINKED_ITEMS_RELAXED_SEMANTIC
01065
01066 CPPUNIT_ASSERT(config.parentItem);
01067 CPPUNIT_ASSERT(config.childItem);
01068
01069 deleteAll(createSourceA);
01070 std::string parent, child;
01071 std::auto_ptr<SyncSource> copy;
01072
01073
01074 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01075 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01076 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01077 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01078 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01079
01080
01081 parent = insert(createSourceA, config.parentItem);
01082 child = insert(createSourceA, config.childItem);
01083
01084 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01085 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01086 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
01087 SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
01088 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01089 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01090 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
01091 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
01092 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01093 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01094
01095 deleteItem(createSourceA, parent);
01096
01097 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01098 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01099 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01100 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01101
01102 SOURCE_ASSERT(copy.get(), 1 >= countUpdatedItems(copy.get()));
01103 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
01104 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
01105 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01106 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01107
01108 deleteItem(createSourceA, child);
01109
01110 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01111 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01112 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01113 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01114 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01115 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
01116 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
01117 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01118 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01119 #endif
01120 }
01121
01122
01123
01124 void LocalTests::testLinkedItemsRemoveNormal() {
01125
01126 CPPUNIT_ASSERT(config.parentItem);
01127 CPPUNIT_ASSERT(config.childItem);
01128
01129 deleteAll(createSourceA);
01130 std::string parent, child;
01131 std::auto_ptr<SyncSource> copy;
01132
01133
01134 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01135 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01136 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01137 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01138 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01139
01140
01141 parent = insert(createSourceA, config.parentItem);
01142 child = insert(createSourceA, config.childItem);
01143
01144 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01145 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01146 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
01147 SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
01148 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01149 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01150 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
01151 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
01152 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01153 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01154
01155 deleteItem(createSourceA, child);
01156
01157 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01158 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01159 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01160 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01161 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01162 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
01163 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
01164 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01165 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01166
01167 deleteItem(createSourceA, parent);
01168
01169 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01170 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01171 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01172 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01173 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01174 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
01175 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
01176 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01177 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01178 }
01179
01180
01181
01182 void LocalTests::testLinkedItemsInsertParentTwice() {
01183
01184 CPPUNIT_ASSERT(config.parentItem);
01185 CPPUNIT_ASSERT(config.childItem);
01186
01187 deleteAll(createSourceA);
01188 std::string parent, child;
01189 std::auto_ptr<SyncSource> copy;
01190
01191
01192 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01193 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01194 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01195 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01196 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01197
01198
01199 parent = insert(createSourceA, config.parentItem);
01200
01201 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01202 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01203 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01204 SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
01205 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01206 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01207 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
01208 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01209 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01210
01211 parent = insert(createSourceA, config.parentItem);
01212
01213 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01214 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01215 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01216 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01217 SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
01218 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01219 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), parent));
01220 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01221 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01222
01223 deleteItem(createSourceA, parent);
01224
01225 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01226 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01227 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01228 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01229 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01230 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
01231 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
01232 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01233 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01234 }
01235
01236
01237
01238 void LocalTests::testLinkedItemsInsertChildTwice() {
01239
01240 CPPUNIT_ASSERT(config.parentItem);
01241 CPPUNIT_ASSERT(config.childItem);
01242
01243 deleteAll(createSourceA);
01244 std::string parent, child;
01245 std::auto_ptr<SyncSource> copy;
01246
01247
01248 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01249 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01250 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01251 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01252 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01253
01254 #if LINKED_ITEMS_RELAXED_SEMANTIC
01255
01256 child = insert(createSourceA, config.childItem);
01257
01258 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01259 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01260 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01261 SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
01262 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01263 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01264 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
01265 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01266 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01267
01268 child = insert(createSourceA, config.childItem);
01269
01270 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01271 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01272 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01273 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01274 SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
01275 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01276 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), child));
01277 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01278 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01279
01280 deleteItem(createSourceA, child);
01281
01282 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01283 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01284 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01285 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01286 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01287 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
01288 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
01289 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01290 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01291 #endif
01292 }
01293
01294
01295
01296 void LocalTests::testLinkedItemsParentUpdate() {
01297
01298 CPPUNIT_ASSERT(config.parentItem);
01299 CPPUNIT_ASSERT(config.childItem);
01300
01301 deleteAll(createSourceA);
01302 std::string parent, child;
01303 std::auto_ptr<SyncSource> copy;
01304
01305
01306 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01307 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01308 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01309 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01310 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01311
01312
01313 parent = insert(createSourceA, config.parentItem);
01314
01315 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01316 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01317 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01318 SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
01319 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01320 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01321 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
01322 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01323 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01324
01325 parent = updateItem(createSourceA, parent, config.parentItem);
01326
01327 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01328 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01329 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01330 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01331 SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
01332 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01333 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), parent));
01334 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01335 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01336
01337 deleteItem(createSourceA, parent);
01338
01339 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01340 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01341 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01342 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01343 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01344 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
01345 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
01346 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01347 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01348 }
01349
01350
01351
01352 void LocalTests::testLinkedItemsUpdateChild() {
01353 #if LINKED_ITEMS_RELAXED_SEMANTIC
01354
01355 CPPUNIT_ASSERT(config.parentItem);
01356 CPPUNIT_ASSERT(config.childItem);
01357
01358 deleteAll(createSourceA);
01359 std::string parent, child;
01360 std::auto_ptr<SyncSource> copy;
01361
01362
01363 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01364 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01365 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01366 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01367 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01368
01369
01370 child = insert(createSourceA, config.childItem);
01371
01372 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01373 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01374 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01375 SOURCE_ASSERT_EQUAL(copy.get(), 1, countNewItems(copy.get()));
01376 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01377 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01378 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
01379 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01380 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01381
01382 child = updateItem(createSourceA, child, config.childItem);
01383
01384 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01385 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01386 SOURCE_ASSERT_EQUAL(copy.get(), 1, countItems(copy.get()));
01387 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01388 SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
01389 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01390 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), child));
01391 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01392 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01393
01394 deleteItem(createSourceA, child);
01395
01396 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01397 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01398 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01399 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01400 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01401 SOURCE_ASSERT_EQUAL(copy.get(), 1, countDeletedItems(copy.get()));
01402 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
01403 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01404 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01405 #endif
01406 }
01407
01408
01409
01410 void LocalTests::testLinkedItemsInsertBothUpdateChild() {
01411
01412 CPPUNIT_ASSERT(config.parentItem);
01413 CPPUNIT_ASSERT(config.childItem);
01414
01415 deleteAll(createSourceA);
01416 std::string parent, child;
01417 std::auto_ptr<SyncSource> copy;
01418
01419
01420 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01421 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01422 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01423 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01424 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01425
01426
01427 parent = insert(createSourceA, config.parentItem);
01428 child = insert(createSourceA, config.childItem);
01429
01430 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01431 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01432 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
01433 SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
01434 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01435 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01436 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
01437 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
01438 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01439 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01440
01441 child = updateItem(createSourceA, child, config.childItem);
01442
01443 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01444 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01445 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
01446 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01447 SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
01448 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01449 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), child));
01450 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01451 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01452
01453 deleteItem(createSourceA, parent);
01454 deleteItem(createSourceA, child);
01455
01456 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01457 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01458 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01459 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01460 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01461 SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
01462 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
01463 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
01464 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01465 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01466 }
01467
01468
01469
01470 void LocalTests::testLinkedItemsInsertBothUpdateParent() {
01471
01472 CPPUNIT_ASSERT(config.parentItem);
01473 CPPUNIT_ASSERT(config.childItem);
01474
01475 deleteAll(createSourceA);
01476 std::string parent, child;
01477 std::auto_ptr<SyncSource> copy;
01478
01479
01480 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01481 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01482 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01483 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01484 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01485
01486
01487 parent = insert(createSourceA, config.parentItem);
01488 child = insert(createSourceA, config.childItem);
01489
01490 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01491 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01492 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
01493 SOURCE_ASSERT_EQUAL(copy.get(), 2, countNewItems(copy.get()));
01494 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01495 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01496 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), child));
01497 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listItems(copy.get()), parent));
01498 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01499 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01500
01501 parent = updateItem(createSourceA, parent, config.parentItem);
01502
01503 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01504 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01505 SOURCE_ASSERT_EQUAL(copy.get(), 2, countItems(copy.get()));
01506 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01507 SOURCE_ASSERT_EQUAL(copy.get(), 1, countUpdatedItems(copy.get()));
01508 SOURCE_ASSERT_EQUAL(copy.get(), 0, countDeletedItems(copy.get()));
01509 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listUpdatedItems(copy.get()), parent));
01510 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01511 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01512
01513 deleteItem(createSourceA, parent);
01514 deleteItem(createSourceA, child);
01515
01516 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(createSourceB()));
01517 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01518 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01519 SOURCE_ASSERT_EQUAL(copy.get(), 0, countNewItems(copy.get()));
01520 SOURCE_ASSERT_EQUAL(copy.get(), 0, countUpdatedItems(copy.get()));
01521 SOURCE_ASSERT_EQUAL(copy.get(), 2, countDeletedItems(copy.get()));
01522 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), parent));
01523 SOURCE_ASSERT_EQUAL(copy.get(), 1, countEqual(listDeletedItems(copy.get()), child));
01524 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01525 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01526 }
01527
01528
01529 SyncTests::SyncTests(const std::string &name, ClientTest &cl, std::vector<int> sourceIndices, bool isClientA) :
01530 CppUnit::TestSuite(name),
01531 client(cl) {
01532 sourceArray = new int[sourceIndices.size() + 1];
01533 for (std::vector<int>::iterator it = sourceIndices.begin();
01534 it != sourceIndices.end();
01535 ++it) {
01536 ClientTest::Config config;
01537 client.getSourceConfig(*it, config);
01538
01539 if (config.sourceName) {
01540 sourceArray[sources.size()] = *it;
01541 sources.push_back(std::pair<int,LocalTests *>(*it, cl.createLocalTests(config.sourceName, *it, config)));
01542 }
01543 }
01544 sourceArray[sources.size()] = -1;
01545
01546
01547 ClientTest *clientB = cl.getClientB();
01548 if (clientB) {
01549 accessClientB = clientB->createSyncTests(name, sourceIndices, false);
01550 } else {
01551 accessClientB = 0;
01552 }
01553 }
01554
01555 SyncTests::~SyncTests() {
01556 for (source_it it = sources.begin();
01557 it != sources.end();
01558 ++it) {
01559 delete it->second;
01560 }
01561 delete [] sourceArray;
01562 if (accessClientB) {
01563 delete accessClientB;
01564 }
01565 }
01566
01567
01568 void SyncTests::addTests() {
01569 if (sources.size()) {
01570 const ClientTest::Config &config(sources[0].second->config);
01571
01572
01573
01574
01575 if (config.createSourceA) {
01576 if (config.insertItem) {
01577 ADD_TEST(SyncTests, testDeleteAllRefresh);
01578 }
01579 }
01580
01581 ADD_TEST(SyncTests, testTwoWaySync);
01582 ADD_TEST(SyncTests, testSlowSync);
01583 ADD_TEST(SyncTests, testRefreshFromServerSync);
01584 ADD_TEST(SyncTests, testRefreshFromClientSync);
01585
01586 if (config.createSourceA) {
01587 if (config.insertItem) {
01588 ADD_TEST(SyncTests, testRefreshSemantic);
01589 ADD_TEST(SyncTests, testRefreshStatus);
01590
01591 if (accessClientB &&
01592 config.dump &&
01593 config.compare) {
01594 ADD_TEST(SyncTests, testCopy);
01595 ADD_TEST(SyncTests, testDelete);
01596 ADD_TEST(SyncTests, testAddUpdate);
01597 ADD_TEST(SyncTests, testManyItems);
01598
01599 if (config.updateItem) {
01600 ADD_TEST(SyncTests, testUpdate);
01601 }
01602 if (config.complexUpdateItem) {
01603 ADD_TEST(SyncTests, testComplexUpdate);
01604 }
01605 if (config.mergeItem1 && config.mergeItem2) {
01606 ADD_TEST(SyncTests, testMerge);
01607 }
01608 if (config.import) {
01609 ADD_TEST(SyncTests, testTwinning);
01610 ADD_TEST(SyncTests, testItems);
01611 }
01612 if (config.templateItem) {
01613 ADD_TEST(SyncTests, testMaxMsg);
01614 ADD_TEST(SyncTests, testLargeObject);
01615 ADD_TEST(SyncTests, testLargeObjectBin);
01616 if (client.isB64Enabled()) {
01617 ADD_TEST(SyncTests, testLargeObjectEncoded);
01618 }
01619 ADD_TEST(SyncTests, testOneWayFromServer);
01620 ADD_TEST(SyncTests, testOneWayFromClient);
01621 }
01622 }
01623 }
01624 }
01625 }
01626 }
01627
01628
01629 void SyncTests::compareDatabases() {
01630 source_it it1;
01631 source_it it2;
01632
01633 CPPUNIT_ASSERT(accessClientB);
01634 for (it1 = sources.begin(), it2 = accessClientB->sources.begin();
01635 it1 != sources.end() && it2 != accessClientB->sources.end();
01636 ++it1, ++it2) {
01637 std::auto_ptr<SyncSource> copy;
01638 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(it2->second->createSourceB()));
01639 it1->second->compareDatabases(NULL, *copy.get());
01640 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01641 }
01642 CPPUNIT_ASSERT(it1 == sources.end());
01643 CPPUNIT_ASSERT(it2 == accessClientB->sources.end());
01644 }
01645
01646
01647 void SyncTests::deleteAll(DeleteAllMode mode) {
01648 source_it it;
01649
01650 switch(mode) {
01651 case DELETE_ALL_SYNC:
01652
01653 for (it = sources.begin(); it != sources.end(); ++it) {
01654 it->second->deleteAll(it->second->createSourceA);
01655 }
01656 sync(SYNC_SLOW, ".deleteall.init");
01657
01658 for (it = sources.begin(); it != sources.end(); ++it) {
01659 it->second->deleteAll(it->second->createSourceA);
01660 }
01661 sync(SYNC_TWO_WAY, ".deleteall.twoway", CheckSyncReport(0,0,0, 0,0,-1));
01662 break;
01663 case DELETE_ALL_REFRESH:
01664
01665 for (it = sources.begin(); it != sources.end(); ++it) {
01666 it->second->deleteAll(it->second->createSourceA);
01667 }
01668 sync(SYNC_REFRESH_FROM_CLIENT, ".deleteall.refreshserver", CheckSyncReport(0,0,0, 0,0,-1));
01669 break;
01670 }
01671 }
01672
01673
01674 void SyncTests::doCopy() {
01675
01676 CPPUNIT_ASSERT(accessClientB);
01677
01678 deleteAll();
01679 accessClientB->deleteAll();
01680
01681
01682 source_it it;
01683 for (it = sources.begin(); it != sources.end(); ++it) {
01684 it->second->testSimpleInsert();
01685 }
01686 sync(SYNC_TWO_WAY, ".send", CheckSyncReport(0,0,0, 1,0,0));
01687
01688
01689 accessClientB->sync(SYNC_TWO_WAY, ".recv", CheckSyncReport(1,0,0, 0,0,0));
01690
01691 compareDatabases();
01692 }
01693
01694
01695
01696
01697
01698
01699 void SyncTests::refreshClient() {
01700 source_it it;
01701 for (it = sources.begin(); it != sources.end(); ++it) {
01702 it->second->deleteAll(it->second->createSourceA);
01703 }
01704 sync(SYNC_SLOW, ".refresh", CheckSyncReport(-1,0,0, 0,0,0));
01705 }
01706
01707
01708
01709 void SyncTests::testDeleteAllRefresh() {
01710 source_it it;
01711
01712
01713
01714 for (it = sources.begin(); it != sources.end(); ++it) {
01715 it->second->testSimpleInsert();
01716 }
01717 sync(SYNC_SLOW, ".insert");
01718
01719
01720 deleteAll(DELETE_ALL_SYNC);
01721
01722
01723 for (it = sources.begin(); it != sources.end(); ++it) {
01724 std::auto_ptr<SyncSource> source;
01725 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceA()));
01726 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
01727 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
01728 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
01729 CPPUNIT_ASSERT_NO_THROW(source.reset());
01730 }
01731
01732
01733 sync(SYNC_SLOW, ".check", CheckSyncReport(0,0,0, 0,0,0));
01734 for (it = sources.begin(); it != sources.end(); ++it) {
01735 std::auto_ptr<SyncSource> source;
01736 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceA()));
01737 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
01738 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
01739 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
01740 CPPUNIT_ASSERT_NO_THROW(source.reset());
01741 }
01742 }
01743
01744
01745
01746 void SyncTests::testRefreshSemantic() {
01747 source_it it;
01748
01749
01750 deleteAll();
01751
01752
01753 for (it = sources.begin(); it != sources.end(); ++it) {
01754 it->second->testSimpleInsert();
01755 }
01756 sync(SYNC_REFRESH_FROM_SERVER, "", CheckSyncReport(0,0,-1, 0,0,0));
01757
01758
01759 for (it = sources.begin(); it != sources.end(); ++it) {
01760 std::auto_ptr<SyncSource> source;
01761 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceA()));
01762 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
01763 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
01764 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
01765 CPPUNIT_ASSERT_NO_THROW(source.reset());
01766 }
01767 sync(SYNC_TWO_WAY, ".two-way", CheckSyncReport(0,0,0, 0,0,0));
01768 }
01769
01770
01771
01772
01773
01774
01775
01776 void SyncTests::testRefreshStatus() {
01777 source_it it;
01778
01779 for (it = sources.begin(); it != sources.end(); ++it) {
01780 it->second->testSimpleInsert();
01781 }
01782 for (it = sources.begin(); it != sources.end(); ++it) {
01783 it->second->deleteAll(it->second->createSourceA);
01784 }
01785 for (it = sources.begin(); it != sources.end(); ++it) {
01786 it->second->testSimpleInsert();
01787 }
01788 sync(SYNC_REFRESH_FROM_CLIENT, ".refresh-from-client", CheckSyncReport(0,0,0 ));
01789 sync(SYNC_TWO_WAY, ".two-way", CheckSyncReport(0,0,0, 0,0,0));
01790 }
01791
01792
01793
01794 void SyncTests::testUpdate() {
01795 CPPUNIT_ASSERT(sources.begin() != sources.end());
01796 CPPUNIT_ASSERT(sources.begin()->second->config.updateItem);
01797
01798
01799 doCopy();
01800
01801 source_it it;
01802 for (it = sources.begin(); it != sources.end(); ++it) {
01803 it->second->update(it->second->createSourceA, it->second->config.updateItem);
01804 }
01805
01806 sync(SYNC_TWO_WAY, ".update", CheckSyncReport(0,0,0, 0,1,0));
01807 accessClientB->sync(SYNC_TWO_WAY, ".update", CheckSyncReport(0,1,0, 0,0,0));
01808
01809 compareDatabases();
01810 }
01811
01812
01813
01814
01815 void SyncTests::testComplexUpdate() {
01816
01817 doCopy();
01818
01819 source_it it;
01820 for (it = sources.begin(); it != sources.end(); ++it) {
01821 it->second->update(it->second->createSourceA,
01822
01823
01824
01825 it->second->config.complexUpdateItem ? it->second->config.complexUpdateItem :
01826 it->second->config.updateItem ? it->second->config.updateItem :
01827 it->second->config.insertItem
01828 );
01829 }
01830
01831 sync(SYNC_TWO_WAY, ".update", CheckSyncReport(0,0,0, 0,1,0));
01832 accessClientB->sync(SYNC_TWO_WAY, ".update", CheckSyncReport(0,1,0, 0,0,0));
01833
01834 compareDatabases();
01835 }
01836
01837
01838
01839 void SyncTests::testDelete() {
01840
01841 doCopy();
01842
01843
01844 source_it it;
01845 for (it = sources.begin(); it != sources.end(); ++it) {
01846 it->second->deleteAll(it->second->createSourceA);
01847 }
01848
01849
01850 sync(SYNC_TWO_WAY, ".delete", CheckSyncReport(0,0,0, 0,0,1));
01851 accessClientB->sync(SYNC_TWO_WAY, ".delete", CheckSyncReport(0,0,1, 0,0,0));
01852
01853
01854 for (it = sources.begin(); it != sources.end(); ++it) {
01855 std::auto_ptr<SyncSource> copy;
01856 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(it->second->createSourceA()));
01857 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01858 SOURCE_ASSERT_EQUAL(copy.get(), 0, countItems(copy.get()));
01859 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01860 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01861 }
01862 }
01863
01864
01865
01866 void SyncTests::testMerge() {
01867
01868 doCopy();
01869
01870
01871 source_it it;
01872 for (it = sources.begin(); it != sources.end(); ++it) {
01873 it->second->update(it->second->createSourceA, it->second->config.mergeItem1);
01874 }
01875
01876
01877 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
01878 it->second->update(it->second->createSourceA, it->second->config.mergeItem2);
01879 }
01880
01881
01882 sync(SYNC_TWO_WAY, ".send", CheckSyncReport(0,0,0, 0,1,0));
01883 sync(SYNC_TWO_WAY, ".recv");
01884
01885
01886 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
01887 std::auto_ptr<SyncSource> copy;
01888 SOURCE_ASSERT_NO_FAILURE(copy.get(), copy.reset(it->second->createSourceA()));
01889 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->beginSync());
01890 int numItems = 0;
01891 SOURCE_ASSERT_NO_FAILURE(copy.get(), numItems = countItems(copy.get()));
01892 SOURCE_ASSERT_EQUAL(copy.get(), 0, copy->endSync());
01893 CPPUNIT_ASSERT(numItems >= 1);
01894 CPPUNIT_ASSERT(numItems <= 2);
01895 std::cout << " " << it->second->config.sourceName << ": " << (numItems == 1 ? "conflicting items were merged" : "both of the conflicting items were preserved") << " ";
01896 std::cout.flush();
01897 CPPUNIT_ASSERT_NO_THROW(copy.reset());
01898 }
01899 }
01900
01901
01902
01903
01904 void SyncTests::testTwinning() {
01905
01906 deleteAll();
01907
01908
01909 source_it it;
01910 for (it = sources.begin(); it != sources.end(); ++it) {
01911 it->second->testImport();
01912 }
01913
01914
01915 sync(SYNC_TWO_WAY, ".send");
01916
01917
01918
01919 refreshClient();
01920
01921
01922 accessClientB->refreshClient();
01923
01924
01925 sync(SYNC_TWO_WAY, ".twinning");
01926
01927
01928 compareDatabases();
01929 }
01930
01931
01932
01933
01934
01935
01936
01937
01938
01939
01940 void SyncTests::testOneWayFromServer() {
01941
01942 deleteAll();
01943 accessClientB->refreshClient();
01944
01945
01946
01947 source_it it;
01948 for (it = sources.begin(); it != sources.end(); ++it) {
01949 if (it->second->config.createSourceB) {
01950 std::auto_ptr<SyncSource> source;
01951 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
01952 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
01953 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
01954 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
01955 CPPUNIT_ASSERT_NO_THROW(source.reset());
01956 }
01957 }
01958 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
01959 if (it->second->config.createSourceB) {
01960 std::auto_ptr<SyncSource> source;
01961 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
01962 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
01963 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
01964 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
01965 CPPUNIT_ASSERT_NO_THROW(source.reset());
01966 }
01967 }
01968
01969
01970 for (it = sources.begin(); it != sources.end(); ++it) {
01971 it->second->insertManyItems(it->second->createSourceA, 1, 1);
01972 }
01973 sync(SYNC_TWO_WAY, ".send", CheckSyncReport(0,0,0, 1,0,0));
01974 for (it = sources.begin(); it != sources.end(); ++it) {
01975 if (it->second->config.createSourceB) {
01976 std::auto_ptr<SyncSource> source;
01977 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
01978 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
01979 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
01980 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
01981 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
01982 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
01983 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
01984 CPPUNIT_ASSERT_NO_THROW(source.reset());
01985 }
01986 }
01987
01988
01989
01990 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
01991 it->second->insertManyItems(it->second->createSourceA, 2, 1);
01992
01993 if (it->second->config.createSourceB) {
01994 std::auto_ptr<SyncSource> source;
01995 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
01996 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
01997 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
01998 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
01999 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02000 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02001 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02002 CPPUNIT_ASSERT_NO_THROW(source.reset());
02003 }
02004 }
02005 accessClientB->sync(SYNC_ONE_WAY_FROM_SERVER, ".recv", CheckSyncReport(1,0,0, 0,0,0));
02006 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
02007 if (it->second->config.createSourceB) {
02008 std::auto_ptr<SyncSource> source;
02009 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02010 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02011 SOURCE_ASSERT_EQUAL(source.get(), 2, countItems(source.get()));
02012 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
02013 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02014 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02015 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02016 CPPUNIT_ASSERT_NO_THROW(source.reset());
02017 }
02018 }
02019
02020
02021
02022 sync(SYNC_TWO_WAY, ".check", CheckSyncReport(0,0,0, 0,0,0));
02023 for (it = sources.begin(); it != sources.end(); ++it) {
02024 if (it->second->config.createSourceB) {
02025 std::auto_ptr<SyncSource> source;
02026 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02027 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02028 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
02029 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
02030 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02031 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02032 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02033 CPPUNIT_ASSERT_NO_THROW(source.reset());
02034 }
02035 }
02036
02037
02038 for (it = sources.begin(); it != sources.end(); ++it) {
02039 it->second->deleteAll(it->second->createSourceA);
02040
02041 if (it->second->config.createSourceB) {
02042 std::auto_ptr<SyncSource> source;
02043 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02044 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02045 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
02046 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
02047 SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
02048 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02049 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02050 CPPUNIT_ASSERT_NO_THROW(source.reset());
02051 }
02052 }
02053 sync(SYNC_TWO_WAY, ".delete", CheckSyncReport(0,0,0, 0,0,1));
02054 for (it = sources.begin(); it != sources.end(); ++it) {
02055 if (it->second->config.createSourceB) {
02056 std::auto_ptr<SyncSource> source;
02057 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02058 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02059 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
02060 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
02061 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02062 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02063 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02064 CPPUNIT_ASSERT_NO_THROW(source.reset());
02065 }
02066 }
02067
02068
02069
02070 accessClientB->sync(SYNC_ONE_WAY_FROM_SERVER, ".delete", CheckSyncReport(0,0,1, 0,0,0));
02071 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
02072 if (it->second->config.createSourceB) {
02073 std::auto_ptr<SyncSource> source;
02074 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02075 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02076 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
02077 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
02078 SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
02079 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02080 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02081 CPPUNIT_ASSERT_NO_THROW(source.reset());
02082 }
02083 }
02084 }
02085
02086
02087
02088
02089
02090
02091
02092
02093
02094
02095 void SyncTests::testOneWayFromClient() {
02096
02097 deleteAll();
02098 accessClientB->deleteAll();
02099
02100
02101
02102 source_it it;
02103 for (it = sources.begin(); it != sources.end(); ++it) {
02104 if (it->second->config.createSourceB) {
02105 std::auto_ptr<SyncSource> source;
02106 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02107 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02108 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
02109 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02110 CPPUNIT_ASSERT_NO_THROW(source.reset());
02111 }
02112 }
02113 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
02114 if (it->second->config.createSourceB) {
02115 std::auto_ptr<SyncSource> source;
02116 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02117 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02118 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
02119 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02120 CPPUNIT_ASSERT_NO_THROW(source.reset());
02121 }
02122 }
02123
02124
02125 for (it = sources.begin(); it != sources.end(); ++it) {
02126 it->second->insertManyItems(it->second->createSourceA, 1, 1);
02127 }
02128 sync(SYNC_TWO_WAY, ".send", CheckSyncReport(0,0,0, 1,0,0));
02129 for (it = sources.begin(); it != sources.end(); ++it) {
02130 if (it->second->config.createSourceB) {
02131 std::auto_ptr<SyncSource> source;
02132 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02133 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02134 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
02135 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
02136 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02137 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02138 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02139 CPPUNIT_ASSERT_NO_THROW(source.reset());
02140 }
02141 }
02142
02143
02144
02145 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
02146 it->second->insertManyItems(it->second->createSourceA, 2, 1);
02147
02148 if (it->second->config.createSourceB) {
02149 std::auto_ptr<SyncSource> source;
02150 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02151 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02152 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
02153 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
02154 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02155 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02156 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02157 CPPUNIT_ASSERT_NO_THROW(source.reset());
02158 }
02159 }
02160 accessClientB->sync(SYNC_ONE_WAY_FROM_CLIENT, ".send", CheckSyncReport(0,0,0, 1,0,0));
02161 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
02162 if (it->second->config.createSourceB) {
02163 std::auto_ptr<SyncSource> source;
02164 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02165 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02166 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
02167 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
02168 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02169 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02170 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02171 CPPUNIT_ASSERT_NO_THROW(source.reset());
02172 }
02173 }
02174
02175
02176
02177 sync(SYNC_TWO_WAY, ".check", CheckSyncReport(1,0,0, 0,0,0));
02178 for (it = sources.begin(); it != sources.end(); ++it) {
02179 if (it->second->config.createSourceB) {
02180 std::auto_ptr<SyncSource> source;
02181 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02182 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02183 SOURCE_ASSERT_EQUAL(source.get(), 2, countItems(source.get()));
02184 SOURCE_ASSERT_EQUAL(source.get(), 1, countNewItems(source.get()));
02185 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02186 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02187 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02188 CPPUNIT_ASSERT_NO_THROW(source.reset());
02189 }
02190 }
02191
02192
02193 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
02194 it->second->deleteAll(it->second->createSourceA);
02195
02196 if (it->second->config.createSourceB) {
02197 std::auto_ptr<SyncSource> source;
02198 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02199 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02200 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
02201 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
02202 SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
02203 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02204 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02205 CPPUNIT_ASSERT_NO_THROW(source.reset());
02206 }
02207 }
02208 accessClientB->sync(SYNC_ONE_WAY_FROM_CLIENT, ".delete", CheckSyncReport(0,0,0, 0,0,1));
02209 for (it = accessClientB->sources.begin(); it != accessClientB->sources.end(); ++it) {
02210 if (it->second->config.createSourceB) {
02211 std::auto_ptr<SyncSource> source;
02212 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02213 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02214 SOURCE_ASSERT_EQUAL(source.get(), 0, countItems(source.get()));
02215 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
02216 SOURCE_ASSERT_EQUAL(source.get(), 0, countDeletedItems(source.get()));
02217 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02218 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02219 CPPUNIT_ASSERT_NO_THROW(source.reset());
02220 }
02221 }
02222
02223
02224
02225 sync(SYNC_TWO_WAY, ".delete", CheckSyncReport(0,0,1, 0,0,0));
02226 for (it = sources.begin(); it != sources.end(); ++it) {
02227 if (it->second->config.createSourceB) {
02228 std::auto_ptr<SyncSource> source;
02229 SOURCE_ASSERT_NO_FAILURE(source.get(), source.reset(it->second->createSourceB()));
02230 SOURCE_ASSERT_EQUAL(source.get(), 0, source->beginSync());
02231 SOURCE_ASSERT_EQUAL(source.get(), 1, countItems(source.get()));
02232 SOURCE_ASSERT_EQUAL(source.get(), 0, countNewItems(source.get()));
02233 SOURCE_ASSERT_EQUAL(source.get(), 1, countDeletedItems(source.get()));
02234 SOURCE_ASSERT_EQUAL(source.get(), 0, countUpdatedItems(source.get()));
02235 SOURCE_ASSERT_EQUAL(source.get(), 0, source->endSync());
02236 CPPUNIT_ASSERT_NO_THROW(source.reset());
02237 }
02238 }
02239 }
02240
02241
02242
02243 void SyncTests::testItems() {
02244
02245 deleteAll();
02246
02247
02248 source_it it;
02249 for (it = sources.begin(); it != sources.end(); ++it) {
02250 it->second->testImport();
02251 }
02252
02253
02254 sync(SYNC_TWO_WAY, ".send");
02255 accessClientB->refreshClient();
02256
02257 compareDatabases();
02258 }
02259
02260
02261
02262
02263
02264
02265
02266
02267
02268
02269
02270 void SyncTests::testAddUpdate() {
02271
02272 deleteAll();
02273 accessClientB->refreshClient();
02274
02275
02276 source_it it;
02277 for (it = sources.begin(); it != sources.end(); ++it) {
02278 it->second->insert(it->second->createSourceA, it->second->config.insertItem);
02279 }
02280 sync(SYNC_TWO_WAY, ".add", CheckSyncReport(0,0,0, 1,0,0));
02281
02282
02283 for (it = sources.begin(); it != sources.end(); ++it) {
02284 it->second->update(it->second->createSourceB, it->second->config.updateItem);
02285 }
02286 sync(SYNC_TWO_WAY, ".update", CheckSyncReport(0,0,0, 0,1,0));
02287
02288
02289 accessClientB->sync(SYNC_TWO_WAY, ".recv", CheckSyncReport(1,0,0, 0,0,0));
02290
02291
02292 compareDatabases();
02293 }
02294
02295
02296
02297
02298
02299
02300
02301
02302
02303 void SyncTests::testManyItems() {
02304
02305 deleteAll();
02306
02307
02308
02309 source_it it;
02310 for (it = sources.begin(); it != sources.end(); ++it) {
02311 it->second->insertManyItems(it->second->createSourceA, 0, it->second->config.numItems, 2000);
02312 }
02313
02314
02315 sync(SYNC_TWO_WAY, ".send", CheckSyncReport(0,0,0, -1,0,0), 64 * 1024, 64 * 1024, true);
02316
02317
02318
02319 refreshClient();
02320
02321
02322 accessClientB->refreshClient();
02323
02324
02325 sync(SYNC_SLOW, ".twinning", CheckSyncReport(-1,-1,-1, -1,-1,-1), 64 * 1024, 64 * 1024, true);
02326
02327
02328 compareDatabases();
02329 }
02330
02331
02332
02333
02334
02335
02336 void SyncTests::doVarSizes(bool withMaxMsgSize,
02337 bool withLargeObject,
02338 const char *encoding) {
02339 static const int maxMsgSize = 8 * 1024;
02340
02341
02342 deleteAll();
02343
02344
02345 source_it it;
02346 for (it = sources.begin(); it != sources.end(); ++it) {
02347 int item = 1;
02348 for (int i = 0; i < 2; i++ ) {
02349 int size = 1;
02350 while (size < 2 * maxMsgSize) {
02351 it->second->insertManyItems(it->second->createSourceA, item, 1, (int)strlen(it->second->config.templateItem) + 10 + size);
02352 size *= 2;
02353 item++;
02354 }
02355 }
02356 }
02357
02358
02359 sync(SYNC_TWO_WAY, ".send",
02360 CheckSyncReport(0,0,0, -1,0,0),
02361 withMaxMsgSize ? maxMsgSize : 0,
02362 withMaxMsgSize ? maxMsgSize * 100 : 0,
02363 withLargeObject,
02364 encoding);
02365
02366
02367 accessClientB->sync(SYNC_REFRESH_FROM_SERVER, ".recv",
02368 CheckSyncReport(-1,0,-1, 0,0,0),
02369 withLargeObject ? maxMsgSize : withMaxMsgSize ? maxMsgSize * 100 : 0,
02370 withMaxMsgSize ? maxMsgSize * 100 : 0,
02371 withLargeObject,
02372 encoding);
02373
02374
02375 compareDatabases();
02376 }
02377
02378 void SyncTests::sync(SyncMode syncMode,
02379 const std::string &logprefix,
02380 CheckSyncReport checkReport,
02381 long maxMsgSize,
02382 long maxObjSize,
02383 bool loSupport,
02384 const char *encoding) {
02385 int res = 0;
02386 static int syncCounter = 0;
02387 static std::string lastTest;
02388 std::stringstream logstream;
02389
02390
02391 if (lastTest != getCurrentTest()) {
02392 syncCounter = 0;
02393 lastTest = getCurrentTest();
02394 }
02395
02396 logstream << std::setw(4) << std::setfill('0') << syncCounter << "_" << getCurrentTest() << logprefix;
02397 std::string logname = logstream.str();
02398 simplifyFilename(logname);
02399 syncCounter++;
02400
02401 std::string logfile = logname + ".client." + (accessClientB ? "A" : "B") + ".log";
02402 remove(logfile.c_str());
02403 LOG.setLogName(logfile.c_str());
02404 LOG.reset();
02405
02406 try {
02407 res = client.sync(sourceArray,
02408 syncMode,
02409 checkReport,
02410 maxMsgSize,
02411 maxObjSize,
02412 loSupport,
02413 encoding);
02414
02415 client.postSync(res, logname);
02416 } catch (...) {
02417 res = 1;
02418 client.postSync(res, logname);
02419
02420
02421 CPPUNIT_ASSERT_NO_THROW( throw );
02422 }
02423 CPPUNIT_ASSERT( !res );
02424 }
02425
02426
02427
02428 class ClientTestFactory : public CppUnit::TestFactory {
02429 public:
02430 ClientTestFactory(ClientTest &c) :
02431 client(c) {}
02432
02433 virtual CppUnit::Test *makeTest() {
02434 int source;
02435 CppUnit::TestSuite *alltests = new CppUnit::TestSuite("Client");
02436 CppUnit::TestSuite *tests;
02437
02438
02439 tests = new CppUnit::TestSuite(alltests->getName() + "::Source");
02440 for (source=0; source < client.getNumSources(); source++) {
02441 ClientTest::Config config;
02442 client.getSourceConfig(source, config);
02443 if (config.sourceName) {
02444 LocalTests *sourcetests =
02445 client.createLocalTests(tests->getName() + "::" + config.sourceName, source, config);
02446 sourcetests->addTests();
02447 tests->addTest(sourcetests);
02448 }
02449 }
02450 alltests->addTest(tests);
02451 tests = 0;
02452
02453
02454 tests = new CppUnit::TestSuite(alltests->getName() + "::Sync");
02455 for (source=0; source < client.getNumSources(); source++) {
02456 ClientTest::Config config;
02457 client.getSourceConfig(source, config);
02458 if (config.sourceName) {
02459 std::vector<int> sources;
02460 sources.push_back(source);
02461 SyncTests *synctests =
02462 client.createSyncTests(tests->getName() + "::" + config.sourceName, sources);
02463 synctests->addTests();
02464 tests->addTest(synctests);
02465 }
02466 }
02467
02468
02469
02470 std::vector<int> sources;
02471 std::string name, name_reversed;
02472 for (source=0; source < client.getNumSources(); source++) {
02473 ClientTest::Config config;
02474 client.getSourceConfig(source, config);
02475 if (config.sourceName) {
02476 sources.push_back(source);
02477 if (name.size() > 0) {
02478 name += "_";
02479 name_reversed = std::string("_") + name_reversed;
02480 }
02481 name += config.sourceName;
02482 name_reversed = config.sourceName + name_reversed;
02483 }
02484 }
02485 if (sources.size() > 1) {
02486 SyncTests *synctests =
02487 client.createSyncTests(tests->getName() + "::" + name, sources);
02488 synctests->addTests();
02489 tests->addTest(synctests);
02490 synctests = 0;
02491
02492
02493 std::reverse(sources.begin(), sources.end());
02494 synctests =
02495 client.createSyncTests(tests->getName() + "::" + name_reversed, sources);
02496 synctests->addTests();
02497 tests->addTest(synctests);
02498 synctests = 0;
02499 }
02500
02501 alltests->addTest(tests);
02502 tests = 0;
02503
02504 return alltests;
02505 }
02506
02507 private:
02508 ClientTest &client;
02509 };
02510
02511 void ClientTest::registerTests()
02512 {
02513 factory = (void *)new ClientTestFactory(*this);
02514 CppUnit::TestFactoryRegistry::getRegistry().registerFactory((CppUnit::TestFactory *)factory);
02515 }
02516
02517 ClientTest::ClientTest(int serverSleepSec, const std::string &serverLog) :
02518 serverSleepSeconds(serverSleepSec),
02519 serverLogFileName(serverLog),
02520 factory(NULL)
02521 {
02522 }
02523
02524 ClientTest::~ClientTest()
02525 {
02526 if(factory) {
02527 CppUnit::TestFactoryRegistry::getRegistry().unregisterFactory((CppUnit::TestFactory *)factory);
02528 delete (CppUnit::TestFactory *)factory;
02529 factory = 0;
02530 }
02531 }
02532
02533 LocalTests *ClientTest::createLocalTests(const std::string &name, int sourceParam, ClientTest::Config &co)
02534 {
02535 return new LocalTests(name, *this, sourceParam, co);
02536 }
02537
02538 SyncTests *ClientTest::createSyncTests(const std::string &name, std::vector<int> sourceIndices, bool isClientA)
02539 {
02540 return new SyncTests(name, *this, sourceIndices, isClientA);
02541 }
02542
02543 int ClientTest::dump(ClientTest &client, SyncSource &source, const char *file)
02544 {
02545 std::ofstream out(file);
02546
02547 std::auto_ptr<SyncItem> item;
02548 SOURCE_ASSERT_NO_FAILURE(&source, item.reset(source.getFirstItem()));
02549 while (item.get()) {
02550 out << (char *)item->getData() << std::endl;
02551 SOURCE_ASSERT_NO_FAILURE(&source, item.reset(source.getNextItem()));
02552 }
02553 out.close();
02554 return out.bad();
02555 }
02556
02557 int ClientTest::import(ClientTest &client, SyncSource &source, const char *file)
02558 {
02559
02560 std::ifstream input;
02561 input.open(file);
02562 CPPUNIT_ASSERT(!input.bad());
02563 CPPUNIT_ASSERT(input.is_open());
02564 std::string data, line;
02565 while (input) {
02566 bool wasend = false;
02567 do {
02568 getline(input, line);
02569 CPPUNIT_ASSERT(!input.bad());
02570
02571
02572 if (line != "\r" && line.size() > 0 || !wasend) {
02573 data += line;
02574 data += "\n";
02575 } else {
02576 importItem(&source, data);
02577 data = "";
02578 }
02579 wasend = !line.compare(0, 4, "END:");
02580 } while(!input.eof());
02581 }
02582 importItem(&source, data);
02583
02584 return 0;
02585 }
02586
02587 bool ClientTest::compare(ClientTest &client, const char *fileA, const char *fileB)
02588 {
02589 std::string cmdstr = std::string("perl synccompare.pl ") + fileA + " " + fileB;
02590 return system(cmdstr.c_str()) == 0;
02591 }
02592
02593
02594 #ifndef WIN32
02595 #include <fcntl.h>
02596 #include "base/globalsdef.h"
02597
02598 USE_NAMESPACE
02599 #endif
02600
02601 void ClientTest::postSync(int res, const std::string &logname)
02602 {
02603 #ifdef WIN32
02604 Sleep(serverSleepSeconds * 1000);
02605 #else
02606 sleep(serverSleepSeconds);
02607
02608
02609 if (serverLogFileName.size()) {
02610 int fd = open(serverLogFileName.c_str(), O_RDWR);
02611
02612 if (fd >= 0) {
02613 std::string cmd = std::string("cp ") + serverLogFileName + " " + logname + ".server.log";
02614 system(cmd.c_str());
02615 ftruncate(fd, 0);
02616 } else {
02617 perror(serverLogFileName.c_str());
02618 }
02619 }
02620 #endif
02621 }
02622
02623 void ClientTest::getTestData(const char *type, Config &config)
02624 {
02625 memset(&config, 0, sizeof(config));
02626 char *numitems = getenv("CLIENT_TEST_NUM_ITEMS");
02627 config.numItems = numitems ? atoi(numitems) : 100;
02628
02629 if (!strcmp(type, "vcard30")) {
02630 config.sourceName = "vcard30";
02631 config.uri = "card3";
02632 config.type = "text/vcard";
02633 config.insertItem =
02634 "BEGIN:VCARD\n"
02635 "VERSION:3.0\n"
02636 "TITLE:tester\n"
02637 "FN:John Doe\n"
02638 "N:Doe;John;;;\n"
02639 "TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
02640 "X-EVOLUTION-FILE-AS:Doe\\, John\n"
02641 "X-MOZILLA-HTML:FALSE\n"
02642 "NOTE:\n"
02643 "END:VCARD\n";
02644 config.updateItem =
02645 "BEGIN:VCARD\n"
02646 "VERSION:3.0\n"
02647 "TITLE:tester\n"
02648 "FN:Joan Doe\n"
02649 "N:Doe;Joan;;;\n"
02650 "X-EVOLUTION-FILE-AS:Doe\\, Joan\n"
02651 "TEL;TYPE=WORK;TYPE=VOICE:business 2\n"
02652 "BDAY:2006-01-08\n"
02653 "X-MOZILLA-HTML:TRUE\n"
02654 "END:VCARD\n";
02655
02656 config.complexUpdateItem =
02657 "BEGIN:VCARD\n"
02658 "VERSION:3.0\n"
02659 "TITLE:tester\n"
02660 "FN:Joan Doe\n"
02661 "N:Doe;Joan;;;\n"
02662 "X-EVOLUTION-FILE-AS:Doe\\, Joan\n"
02663 "TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
02664 "TEL;TYPE=HOME;TYPE=VOICE:home 2\n"
02665 "BDAY:2006-01-08\n"
02666 "X-MOZILLA-HTML:TRUE\n"
02667 "END:VCARD\n";
02668
02669 config.mergeItem1 =
02670 "BEGIN:VCARD\n"
02671 "VERSION:3.0\n"
02672 "TITLE:tester\n"
02673 "FN:John Doe\n"
02674 "N:Doe;John;;;\n"
02675 "X-EVOLUTION-FILE-AS:Doe\\, John\n"
02676 "X-MOZILLA-HTML:FALSE\n"
02677 "TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
02678 "EMAIL:john.doe@work.com\n"
02679 "X-AIM:AIM JOHN\n"
02680 "END:VCARD\n";
02681 config.mergeItem2 =
02682 "BEGIN:VCARD\n"
02683 "VERSION:3.0\n"
02684 "TITLE:developer\n"
02685 "FN:John Doe\n"
02686 "N:Doe;John;;;\n"
02687 "X-EVOLUTION-FILE-AS:Doe\\, John\n"
02688 "X-MOZILLA-HTML:TRUE\n"
02689 "BDAY:2006-01-08\n"
02690 "END:VCARD\n";
02691 config.templateItem = config.insertItem;
02692 config.uniqueProperties = "FN:N:X-EVOLUTION-FILE-AS";
02693 config.sizeProperty = "NOTE";
02694 config.import = import;
02695 config.dump = dump;
02696 config.compare = compare;
02697 config.testcases = "testcases/vcard30.vcf";
02698 } else if (!strcmp(type, "vcard21")) {
02699 config.sourceName = "vcard21";
02700 config.uri = "card";
02701 config.type = "text/x-vcard";
02702 config.insertItem =
02703 "BEGIN:VCARD\n"
02704 "VERSION:2.1\n"
02705 "TITLE:tester\n"
02706 "FN:John Doe\n"
02707 "N:Doe;John;;;\n"
02708 "TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
02709 "X-MOZILLA-HTML:FALSE\n"
02710 "NOTE:\n"
02711 "END:VCARD\n";
02712 config.updateItem =
02713 "BEGIN:VCARD\n"
02714 "VERSION:2.1\n"
02715 "TITLE:tester\n"
02716 "FN:Joan Doe\n"
02717 "N:Doe;Joan;;;\n"
02718 "TEL;TYPE=WORK;TYPE=VOICE:business 2\n"
02719 "BDAY:2006-01-08\n"
02720 "X-MOZILLA-HTML:TRUE\n"
02721 "END:VCARD\n";
02722
02723 config.complexUpdateItem =
02724 "BEGIN:VCARD\n"
02725 "VERSION:2.1\n"
02726 "TITLE:tester\n"
02727 "FN:Joan Doe\n"
02728 "N:Doe;Joan;;;\n"
02729 "TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
02730 "TEL;TYPE=HOME;TYPE=VOICE:home 2\n"
02731 "BDAY:2006-01-08\n"
02732 "X-MOZILLA-HTML:TRUE\n"
02733 "END:VCARD\n";
02734
02735 config.mergeItem1 =
02736 "BEGIN:VCARD\n"
02737 "VERSION:2.1\n"
02738 "TITLE:tester\n"
02739 "FN:John Doe\n"
02740 "N:Doe;John;;;\n"
02741 "X-MOZILLA-HTML:FALSE\n"
02742 "TEL;TYPE=WORK;TYPE=VOICE:business 1\n"
02743 "EMAIL:john.doe@work.com\n"
02744 "X-AIM:AIM JOHN\n"
02745 "END:VCARD\n";
02746 config.mergeItem2 =
02747 "BEGIN:VCARD\n"
02748 "VERSION:2.1\n"
02749 "TITLE:developer\n"
02750 "FN:John Doe\n"
02751 "N:Doe;John;;;\n"
02752 "X-MOZILLA-HTML:TRUE\n"
02753 "BDAY:2006-01-08\n"
02754 "END:VCARD\n";
02755 config.templateItem = config.insertItem;
02756 config.uniqueProperties = "FN:N";
02757 config.sizeProperty = "NOTE";
02758 config.import = import;
02759 config.dump = dump;
02760 config.compare = compare;
02761 config.testcases = "testcases/vcard21.vcf";
02762 } else if(!strcmp(type, "ical20")) {
02763 config.sourceName = "ical20";
02764 config.uri = "cal2";
02765 config.type = "text/x-vcalendar";
02766 config.insertItem =
02767 "BEGIN:VCALENDAR\n"
02768 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02769 "VERSION:2.0\n"
02770 "METHOD:PUBLISH\n"
02771 "BEGIN:VEVENT\n"
02772 "SUMMARY:phone meeting\n"
02773 "DTEND:20060406T163000Z\n"
02774 "DTSTART:20060406T160000Z\n"
02775 "UID:1234567890!@#$%^&*()<>@dummy\n"
02776 "DTSTAMP:20060406T211449Z\n"
02777 "LAST-MODIFIED:20060409T213201\n"
02778 "CREATED:20060409T213201\n"
02779 "LOCATION:my office\n"
02780 "DESCRIPTION:let's talk\n"
02781 "CLASS:PUBLIC\n"
02782 "TRANSP:OPAQUE\n"
02783 "SEQUENCE:1\n"
02784 "END:VEVENT\n"
02785 "END:VCALENDAR\n";
02786 config.updateItem =
02787 "BEGIN:VCALENDAR\n"
02788 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02789 "VERSION:2.0\n"
02790 "METHOD:PUBLISH\n"
02791 "BEGIN:VEVENT\n"
02792 "SUMMARY:meeting on site\n"
02793 "DTEND:20060406T163000Z\n"
02794 "DTSTART:20060406T160000Z\n"
02795 "UID:1234567890!@#$%^&*()<>@dummy\n"
02796 "DTSTAMP:20060406T211449Z\n"
02797 "LAST-MODIFIED:20060409T213201\n"
02798 "CREATED:20060409T213201\n"
02799 "LOCATION:big meeting room\n"
02800 "DESCRIPTION:nice to see you\n"
02801 "CLASS:PUBLIC\n"
02802 "TRANSP:OPAQUE\n"
02803 "SEQUENCE:1\n"
02804 "END:VEVENT\n"
02805 "END:VCALENDAR\n";
02806
02807 config.mergeItem1 =
02808 "BEGIN:VCALENDAR\n"
02809 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02810 "VERSION:2.0\n"
02811 "METHOD:PUBLISH\n"
02812 "BEGIN:VEVENT\n"
02813 "SUMMARY:phone meeting\n"
02814 "DTEND:20060406T163000Z\n"
02815 "DTSTART:20060406T160000Z\n"
02816 "UID:1234567890!@#$%^&*()<>@dummy\n"
02817 "DTSTAMP:20060406T211449Z\n"
02818 "LAST-MODIFIED:20060409T213201\n"
02819 "CREATED:20060409T213201\n"
02820 "LOCATION:calling from home\n"
02821 "DESCRIPTION:let's talk\n"
02822 "CLASS:PUBLIC\n"
02823 "TRANSP:OPAQUE\n"
02824 "SEQUENCE:1\n"
02825 "END:VEVENT\n"
02826 "END:VCALENDAR\n";
02827 config.mergeItem2 =
02828 "BEGIN:VCALENDAR\n"
02829 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02830 "VERSION:2.0\n"
02831 "METHOD:PUBLISH\n"
02832 "BEGIN:VEVENT\n"
02833 "SUMMARY:phone meeting\n"
02834 "DTEND:20060406T163000Z\n"
02835 "DTSTART:20060406T160000Z\n"
02836 "UID:1234567890!@#$%^&*()<>@dummy\n"
02837 "DTSTAMP:20060406T211449Z\n"
02838 "LAST-MODIFIED:20060409T213201\n"
02839 "CREATED:20060409T213201\n"
02840 "LOCATION:my office\n"
02841 "DESCRIPTION:what the heck\\, let's even shout a bit\n"
02842 "CLASS:PUBLIC\n"
02843 "TRANSP:OPAQUE\n"
02844 "SEQUENCE:1\n"
02845 "END:VEVENT\n"
02846 "END:VCALENDAR\n";
02847 config.parentItem =
02848 "BEGIN:VCALENDAR\n"
02849 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02850 "VERSION:2.0\n"
02851 "METHOD:PUBLISH\n"
02852 "BEGIN:VEVENT\n"
02853 "UID:20080407T193125Z-19554-727-1-50@gollum\n"
02854 "DTSTAMP:20080407T193125Z\n"
02855 "DTSTART:20080406T090000Z\n"
02856 "DTEND:20080406T093000Z\n"
02857 "TRANSP:OPAQUE\n"
02858 "SEQUENCE:2\n"
02859 "SUMMARY:Recurring\n"
02860 "DESCRIPTION:recurs each Monday\\, 10 times\n"
02861 "CLASS:PUBLIC\n"
02862 "RRULE:FREQ=WEEKLY;COUNT=10;INTERVAL=1;BYDAY=SU\n"
02863 "CREATED:20080407T193241\n"
02864 "LAST-MODIFIED:20080407T193241\n"
02865 "END:VEVENT\n"
02866 "END:VCALENDAR\n";
02867 config.childItem =
02868 "BEGIN:VCALENDAR\n"
02869 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02870 "VERSION:2.0\n"
02871 "METHOD:PUBLISH\n"
02872 "BEGIN:VEVENT\n"
02873 "UID:20080407T193125Z-19554-727-1-50@gollum\n"
02874 "DTSTAMP:20080407T193125Z\n"
02875 "DTSTART:20080413T090000Z\n"
02876 "DTEND:20080413T093000Z\n"
02877 "TRANSP:OPAQUE\n"
02878 "SEQUENCE:7\n"
02879 "SUMMARY:Recurring: Modified\n"
02880 "CLASS:PUBLIC\n"
02881 "CREATED:20080407T193241\n"
02882 "LAST-MODIFIED:20080407T193647\n"
02883 "RECURRENCE-ID:20080413T090000Z\n"
02884 "DESCRIPTION:second instance modified\n"
02885 "END:VEVENT\n"
02886 "END:VCALENDAR\n";
02887 config.templateItem = config.insertItem;
02888 config.uniqueProperties = "SUMMARY:UID:LOCATION";
02889 config.sizeProperty = "DESCRIPTION";
02890 config.import = import;
02891 config.dump = dump;
02892 config.compare = compare;
02893 config.testcases = "testcases/ical20.ics";
02894 } if(!strcmp(type, "vcal10")) {
02895 config.sourceName = "vcal10";
02896 config.uri = "cal";
02897 config.type = "text/x-vcalendar";
02898 config.insertItem =
02899 "BEGIN:VCALENDAR\n"
02900 "VERSION:1.0\n"
02901 "BEGIN:VEVENT\n"
02902 "SUMMARY:phone meeting\n"
02903 "DTEND:20060406T163000Z\n"
02904 "DTSTART:20060406T160000Z\n"
02905 "DTSTAMP:20060406T211449Z\n"
02906 "LOCATION:my office\n"
02907 "DESCRIPTION:let's talk\n"
02908 "END:VEVENT\n"
02909 "END:VCALENDAR\n";
02910 config.updateItem =
02911 "BEGIN:VCALENDAR\n"
02912 "VERSION:1.0\n"
02913 "BEGIN:VEVENT\n"
02914 "SUMMARY:meeting on site\n"
02915 "DTEND:20060406T163000Z\n"
02916 "DTSTART:20060406T160000Z\n"
02917 "DTSTAMP:20060406T211449Z\n"
02918 "LOCATION:big meeting room\n"
02919 "DESCRIPTION:nice to see you\n"
02920 "END:VEVENT\n"
02921 "END:VCALENDAR\n";
02922
02923 config.mergeItem1 =
02924 "BEGIN:VCALENDAR\n"
02925 "VERSION:1.0\n"
02926 "BEGIN:VEVENT\n"
02927 "SUMMARY:phone meeting\n"
02928 "DTEND:20060406T163000Z\n"
02929 "DTSTART:20060406T160000Z\n"
02930 "DTSTAMP:20060406T211449Z\n"
02931 "LOCATION:calling from home\n"
02932 "DESCRIPTION:let's talk\n"
02933 "END:VEVENT\n"
02934 "END:VCALENDAR\n";
02935 config.mergeItem2 =
02936 "BEGIN:VCALENDAR\n"
02937 "VERSION:1.0\n"
02938 "BEGIN:VEVENT\n"
02939 "SUMMARY:phone meeting\n"
02940 "DTEND:20060406T163000Z\n"
02941 "DTSTART:20060406T160000Z\n"
02942 "DTSTAMP:20060406T211449Z\n"
02943 "LOCATION:my office\n"
02944 "DESCRIPTION:what the heck, let's even shout a bit\n"
02945 "END:VEVENT\n"
02946 "END:VCALENDAR\n";
02947 config.templateItem = config.insertItem;
02948 config.uniqueProperties = "SUMMARY:UID:LOCATION";
02949 config.sizeProperty = "DESCRIPTION";
02950 config.import = import;
02951 config.dump = dump;
02952 config.compare = compare;
02953 config.testcases = "testcases/vcal10.ics";
02954 } else if(!strcmp(type, "itodo20")) {
02955 config.sourceName = "itodo20";
02956 config.uri = "task2";
02957 config.type = "text/x-vcalendar";
02958 config.insertItem =
02959 "BEGIN:VCALENDAR\n"
02960 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02961 "VERSION:2.0\n"
02962 "METHOD:PUBLISH\n"
02963 "BEGIN:VTODO\n"
02964 "UID:20060417T173712Z-4360-727-1-2730@gollum\n"
02965 "DTSTAMP:20060417T173712Z\n"
02966 "SUMMARY:do me\n"
02967 "DESCRIPTION:to be done\n"
02968 "PRIORITY:0\n"
02969 "STATUS:IN-PROCESS\n"
02970 "CREATED:20060417T173712\n"
02971 "LAST-MODIFIED:20060417T173712\n"
02972 "END:VTODO\n"
02973 "END:VCALENDAR\n";
02974 config.updateItem =
02975 "BEGIN:VCALENDAR\n"
02976 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02977 "VERSION:2.0\n"
02978 "METHOD:PUBLISH\n"
02979 "BEGIN:VTODO\n"
02980 "UID:20060417T173712Z-4360-727-1-2730@gollum\n"
02981 "DTSTAMP:20060417T173712Z\n"
02982 "SUMMARY:do me ASAP\n"
02983 "DESCRIPTION:to be done\n"
02984 "PRIORITY:1\n"
02985 "STATUS:IN-PROCESS\n"
02986 "CREATED:20060417T173712\n"
02987 "LAST-MODIFIED:20060417T173712\n"
02988 "END:VTODO\n"
02989 "END:VCALENDAR\n";
02990
02991 config.mergeItem1 =
02992 "BEGIN:VCALENDAR\n"
02993 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
02994 "VERSION:2.0\n"
02995 "METHOD:PUBLISH\n"
02996 "BEGIN:VTODO\n"
02997 "UID:20060417T173712Z-4360-727-1-2730@gollum\n"
02998 "DTSTAMP:20060417T173712Z\n"
02999 "SUMMARY:do me please\\, please\n"
03000 "DESCRIPTION:to be done\n"
03001 "PRIORITY:0\n"
03002 "STATUS:IN-PROCESS\n"
03003 "CREATED:20060417T173712\n"
03004 "LAST-MODIFIED:20060417T173712\n"
03005 "END:VTODO\n"
03006 "END:VCALENDAR\n";
03007 config.mergeItem2 =
03008 "BEGIN:VCALENDAR\n"
03009 "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n"
03010 "VERSION:2.0\n"
03011 "METHOD:PUBLISH\n"
03012 "BEGIN:VTODO\n"
03013 "UID:20060417T173712Z-4360-727-1-2730@gollum\n"
03014 "DTSTAMP:20060417T173712Z\n"
03015 "SUMMARY:do me\n"
03016 "DESCRIPTION:to be done\n"
03017 "PRIORITY:7\n"
03018 "STATUS:IN-PROCESS\n"
03019 "CREATED:20060417T173712\n"
03020 "LAST-MODIFIED:20060417T173712\n"
03021 "END:VTODO\n"
03022 "END:VCALENDAR\n";
03023 config.templateItem = config.insertItem;
03024 config.uniqueProperties = "SUMMARY:UID";
03025 config.sizeProperty = "DESCRIPTION";
03026 config.import = import;
03027 config.dump = dump;
03028 config.compare = compare;
03029 config.testcases = "testcases/itodo20.ics";
03030 }
03031 }
03032
03033 void CheckSyncReport::check(int res, SyncReport &report) const
03034 {
03035
03036 StringBuffer str, tmp;
03037
03038 report.toString(str, 1);
03039 str += "----------|--------CLIENT---------|--------SERVER---------|\n";
03040 str += " | NEW | MOD | DEL | NEW | MOD | DEL |\n";
03041 str += "----------|-----------------------------------------------|\n";
03042 str += tmp.sprintf("Expected | %3d | %3d | %3d | %3d | %3d | %3d |\n",
03043 clientAdded, clientUpdated, clientDeleted,
03044 serverAdded, serverUpdated, serverDeleted);
03045 LOG.info("%s", str.c_str());
03046
03047 CPPUNIT_ASSERT_MESSAGE("synchronization failed", !res);
03048
03049
03050 for (unsigned int i=0; report.getSyncSourceReport(i); i++) {
03051 SyncSourceReport* ssr = report.getSyncSourceReport(i);
03052 if (ssr->getState() == SOURCE_INACTIVE) {
03053 continue;
03054 }
03055
03056 const char *name = ssr->getSourceName();
03057 LOG.debug("Checking sync source %s...", name);
03058 CLIENT_TEST_EQUAL(name, 0, ssr->getItemReportFailedCount(CLIENT, COMMAND_ADD));
03059 if (clientAdded != -1) {
03060 CLIENT_TEST_EQUAL(name, clientAdded, ssr->getItemReportSuccessfulCount(CLIENT, COMMAND_ADD));
03061 }
03062 CLIENT_TEST_EQUAL(name, 0, ssr->getItemReportFailedCount(CLIENT, COMMAND_REPLACE));
03063 if (clientUpdated != -1) {
03064 CLIENT_TEST_EQUAL(name, clientUpdated, ssr->getItemReportSuccessfulCount(CLIENT, COMMAND_REPLACE));
03065 }
03066 CLIENT_TEST_EQUAL(name, 0, ssr->getItemReportFailedCount(CLIENT, COMMAND_DELETE));
03067 if (clientDeleted != -1) {
03068 CLIENT_TEST_EQUAL(name, clientDeleted, ssr->getItemReportSuccessfulCount(CLIENT, COMMAND_DELETE));
03069 }
03070
03071 CLIENT_TEST_EQUAL(name, 0, ssr->getItemReportFailedCount(SERVER, COMMAND_ADD));
03072 if (serverAdded != -1) {
03073 CLIENT_TEST_EQUAL(name, serverAdded, ssr->getItemReportSuccessfulCount(SERVER, COMMAND_ADD));
03074 }
03075 CLIENT_TEST_EQUAL(name, 0, ssr->getItemReportFailedCount(SERVER, COMMAND_REPLACE));
03076 if (serverUpdated != -1) {
03077 CLIENT_TEST_EQUAL(name, serverUpdated, ssr->getItemReportSuccessfulCount(SERVER, COMMAND_REPLACE));
03078 }
03079 CLIENT_TEST_EQUAL(name, 0, ssr->getItemReportFailedCount(SERVER, COMMAND_DELETE));
03080 if (serverDeleted != -1) {
03081 CLIENT_TEST_EQUAL(name, serverDeleted, ssr->getItemReportSuccessfulCount(SERVER, COMMAND_DELETE));
03082 }
03083 }
03084 LOG.debug("Done with checking sync report.");
03085 }
03086
03087
03088
03089 #endif // ENABLE_INTEGRATION_TESTS