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