Changeset 496

Show
Ignore:
Timestamp:
07/15/08 17:42:44 (4 months ago)
Author:
bellmich
Message:

Updated the tests to the actual code base.

OMA DS 1.2 SANs are not covered.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/tests/check_sync.c

    r478 r496  
    5656unsigned int session_errors = 0; 
    5757 
     58/* This is a sync test only and not a test of large object support. 
     59 * Therefore all commands must be put into one message. 
     60 * This means one message per package. 
     61 */ 
     62#define TEST_DEFAULT_MAX_MSG_SIZE    1024000 
     63#define TEST_DEFAULT_MAX_OBJ_SIZE    1024000 
     64int num_changes; 
     65SmlError *eventError = NULL; 
     66 
    5867static void _manager_event(SmlManager *manager, SmlManagerEventType type, SmlSession *session, SmlError *error, void *userdata) 
    5968{ 
     
    7382                        break; 
    7483                case SML_MANAGER_TRANSPORT_ERROR: 
     84                        smlTrace(TRACE_INTERNAL, "%s - error: %s", __func__, smlErrorPrint(&error)); 
     85                        eventError = error; 
     86                        smlErrorRef(&eventError); 
    7587                        transport_errors++; 
    7688                        break; 
     
    89101                case SML_MANAGER_SESSION_ERROR: 
    90102                case SML_MANAGER_SESSION_WARNING: 
     103                        smlTrace(TRACE_INTERNAL, "%s - error: %s", __func__, smlErrorPrint(&error)); 
     104                        eventError = error; 
     105                        smlErrorRef(&eventError); 
    91106                        session_errors++; 
    92107                        break; 
     
    241256        smlTrace(TRACE_ENTRY, "%s()", __func__); 
    242257         
    243         fail_unless(numChanges != 87, NULL); 
     258        fail_unless(numChanges == num_changes, NULL); 
    244259        syncs_received++; 
    245260                 
     
    291306        SmlManager *servermanager = servertracker->manager = smlManagerNew(server, &error); 
    292307        smlManagerSetEventCallback(servertracker->manager, _manager_event, servertracker); 
     308        smlManagerSetLocalMaxMsgSize(servertracker->manager, TEST_DEFAULT_MAX_MSG_SIZE); 
     309        smlManagerSetLocalMaxObjSize(servertracker->manager, TEST_DEFAULT_MAX_OBJ_SIZE); 
    293310         
    294311        fail_unless(smlTransportInitialize(client, &error), NULL); 
     
    362379        fail_unless(error == NULL, NULL); 
    363380         
    364         while (init_alerts_received != 3 || num_sessions != 2) { 
    365                 smlManagerDispatch(servermanager); 
    366                 smlManagerDispatch(clientmanager); 
    367                 usleep(100); 
     381        while (init_alerts_received < 3 || num_sessions < 2) { 
     382                smlManagerDispatch(servermanager); 
     383                smlManagerDispatch(clientmanager); 
     384                usleep(100); 
     385                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
    368386        } 
    369387         
     
    377395        smlSessionUnref(servertracker->session); 
    378396         
    379         while (num_end != 2 || replies_received != 3 || num_finals != 2) { 
    380                 smlManagerDispatch(servermanager); 
    381                 smlManagerDispatch(clientmanager); 
    382                 usleep(100); 
     397        while (num_end < 2 || replies_received < 3 || num_finals < 2) { 
     398                smlManagerDispatch(servermanager); 
     399                smlManagerDispatch(clientmanager); 
     400                usleep(100); 
     401                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
    383402        } 
    384403         
     
    426445{ 
    427446        int num_items = 10; 
     447        num_changes = 3 * num_items; 
    428448         
    429449        init_alerts_received = 0; 
     
    463483        SmlManager *servermanager = servertracker->manager = smlManagerNew(server, &error); 
    464484        smlManagerSetEventCallback(servertracker->manager, _manager_event, servertracker); 
     485        smlManagerSetLocalMaxMsgSize(servertracker->manager, TEST_DEFAULT_MAX_MSG_SIZE); 
     486        smlManagerSetLocalMaxObjSize(servertracker->manager, TEST_DEFAULT_MAX_OBJ_SIZE); 
    465487         
    466488        fail_unless(smlTransportInitialize(client, &error), NULL); 
     
    533555        fail_unless(error == NULL, NULL); 
    534556         
    535         while (init_alerts_received != 3 || num_sessions != 2) { 
    536                 smlManagerDispatch(servermanager); 
    537                 smlManagerDispatch(clientmanager); 
    538                 usleep(100); 
     557        while (init_alerts_received < 3 || num_sessions < 2) { 
     558                smlManagerDispatch(servermanager); 
     559                smlManagerDispatch(clientmanager); 
     560                usleep(100); 
     561                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
    539562        } 
    540563         
     
    554577        smlDsSessionGetAlert(clienttracker->dssessions[2], _recv_alert, GINT_TO_POINTER(1)); 
    555578         
    556         while (alerts_received != 6) { 
     579        while (alerts_received < 6) { 
     580                smlDsSessionDispatch(servertracker->dssessions[0]); 
     581                smlDsSessionDispatch(servertracker->dssessions[1]); 
     582                smlDsSessionDispatch(servertracker->dssessions[2]); 
     583                 
     584                smlDsSessionDispatch(clienttracker->dssessions[0]); 
     585                smlDsSessionDispatch(clienttracker->dssessions[1]); 
     586                smlDsSessionDispatch(clienttracker->dssessions[2]); 
     587                 
     588                smlManagerDispatch(servermanager); 
     589                smlManagerDispatch(clientmanager); 
     590                usleep(100); 
     591                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     592        } 
     593 
     594        const char *content_types[] = {SML_ELEMENT_TEXT_VCARD, SML_ELEMENT_TEXT_VCAL, SML_ELEMENT_TEXT_PLAIN}; 
     595        int k = 0; 
     596        for (k = 0; k < 3; k++) 
     597        { 
     598                smlDsSessionSendSync(clienttracker->dssessions[k], num_changes, _sync_reply, GINT_TO_POINTER(1), &error); 
     599         
     600                int i = 0; 
     601                for (i = 0; i < num_items; i++) { 
     602                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_ADD, "uid", "data", 4, content_types[k], _add_reply, GINT_TO_POINTER(2), &error), NULL); 
     603                        fail_unless(error == NULL, NULL); 
     604                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_REPLACE, "uid", "newdata", 7, content_types[k], _modify_reply, GINT_TO_POINTER(1), &error), NULL); 
     605                        fail_unless(error == NULL, NULL); 
     606                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_DELETE, "uid", NULL, 0, content_types[k], _delete_reply, GINT_TO_POINTER(1), &error), NULL); 
     607                        fail_unless(error == NULL, NULL); 
     608                } 
     609 
     610                smlDsSessionCloseSync(clienttracker->dssessions[k], &error); 
     611        } 
     612 
     613        fail_unless(smlSessionFlush(clienttracker->session, TRUE, &error), NULL); 
     614         
     615        smlDsSessionGetSync(servertracker->dssessions[0], _recv_sync, GINT_TO_POINTER(1)); 
     616        smlDsSessionGetSync(servertracker->dssessions[1], _recv_sync, GINT_TO_POINTER(1)); 
     617        smlDsSessionGetSync(servertracker->dssessions[2], _recv_sync, GINT_TO_POINTER(1)); 
     618        smlDsSessionGetChanges(servertracker->dssessions[0], _recv_changes, GINT_TO_POINTER(1)); 
     619        smlDsSessionGetChanges(servertracker->dssessions[1], _recv_changes, GINT_TO_POINTER(1)); 
     620        smlDsSessionGetChanges(servertracker->dssessions[2], _recv_changes, GINT_TO_POINTER(1)); 
     621         
     622        while (syncs_received < 3 || adds_received < num_items * 3 || deletes_received < num_items * 3 || modifies_received < num_items * 3) { 
     623                smlDsSessionDispatch(servertracker->dssessions[0]); 
     624                smlDsSessionDispatch(servertracker->dssessions[1]); 
     625                smlDsSessionDispatch(servertracker->dssessions[2]); 
     626                 
     627                smlDsSessionDispatch(clienttracker->dssessions[0]); 
     628                smlDsSessionDispatch(clienttracker->dssessions[1]); 
     629                smlDsSessionDispatch(clienttracker->dssessions[2]); 
     630                 
     631                smlManagerDispatch(servermanager); 
     632                smlManagerDispatch(clientmanager); 
     633                usleep(100); 
     634                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     635        } 
     636         
     637        fail_unless(servertracker->session != NULL, NULL); 
     638        fail_unless(smlSessionEnd(servertracker->session, &error), NULL); 
     639        fail_unless(error == NULL, NULL); 
     640        smlSessionUnref(servertracker->session); 
     641        smlSessionUnref(clienttracker->session); 
     642         
     643        while (num_end < 2 || replies_received < 9 || num_finals < 4) { 
     644                smlManagerDispatch(servermanager); 
     645                smlManagerDispatch(clientmanager); 
     646                usleep(100); 
     647                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     648        } 
     649         
     650        fail_unless(init_alerts_received == 3, NULL); 
     651        fail_unless(alerts_received == 6, NULL); 
     652        fail_unless(syncs_received == 3, NULL); 
     653        fail_unless(sync_ends_received == 0, NULL); 
     654        fail_unless(changes_received == 0, NULL); 
     655        fail_unless(replies_received == 9, NULL); 
     656        fail_unless(adds_received == num_items * 3, NULL); 
     657        fail_unless(add_replies_received == num_items * 3, NULL); 
     658        fail_unless(deletes_received == num_items * 3, NULL); 
     659        fail_unless(delete_replies_received == num_items * 3, NULL); 
     660        fail_unless(modifies_received == num_items * 3, NULL); 
     661        fail_unless(modify_replies_received == num_items * 3, NULL); 
     662        fail_unless(transport_errors == 0, NULL); 
     663        fail_unless(num_sessions == 2, NULL); 
     664        fail_unless(num_finals == 4, NULL); 
     665        fail_unless(num_end == 2, NULL); 
     666        fail_unless(session_errors == 0, NULL); 
     667         
     668         
     669        smlDsSessionUnref(clienttracker->dssessions[0]); 
     670        smlDsSessionUnref(clienttracker->dssessions[1]); 
     671        smlDsSessionUnref(clienttracker->dssessions[2]); 
     672         
     673        smlDsSessionUnref(servertracker->dssessions[0]); 
     674        smlDsSessionUnref(servertracker->dssessions[1]); 
     675        smlDsSessionUnref(servertracker->dssessions[2]); 
     676         
     677        smlDsServerFree(clienttracker->ds[0]); 
     678        smlDsServerFree(clienttracker->ds[1]); 
     679        smlDsServerFree(clienttracker->ds[2]); 
     680         
     681        smlDsServerFree(servertracker->ds[0]); 
     682        smlDsServerFree(servertracker->ds[1]); 
     683        smlDsServerFree(servertracker->ds[2]); 
     684         
     685        smlAuthFree(auth); 
     686        smlAuthFree(auth2); 
     687         
     688        g_free(clienttracker); 
     689        g_free(servertracker); 
     690         
     691        smlManagerStop(clientmanager); 
     692        smlManagerStop(servermanager); 
     693         
     694        smlManagerFree(clientmanager); 
     695        smlManagerFree(servermanager); 
     696         
     697        fail_unless(smlTransportFinalize(server, &error), NULL); 
     698        fail_unless(smlTransportFinalize(client, &error), NULL); 
     699         
     700        smlTransportFree(server); 
     701        smlTransportFree(client); 
     702
     703END_TEST 
     704 
     705/* client -- 3 * alert ---> server 
     706 * server -- statuses, 3 * alert ---> client 
     707 * client -- statuses, num * add, num * replace, num * delete ---> server 
     708 * server -- statuses, num * add, num * replace, num * delete  ---> client 
     709 * client -- statuses, map ---> server 
     710 * server -- statuses ---> client 
     711 */ 
     712START_TEST (sync_multi_stress2) 
     713
     714        int num_items = 100; 
     715        num_changes = 3 * num_items; 
     716         
     717        init_alerts_received = 0; 
     718        alerts_received = 0; 
     719        syncs_received = 0; 
     720        sync_ends_received = 0; 
     721        changes_received = 0; 
     722        replies_received = 0; 
     723        adds_received = 0; 
     724        add_replies_received = 0; 
     725        deletes_received = 0; 
     726        delete_replies_received = 0; 
     727        modifies_received = 0; 
     728        modify_replies_received = 0; 
     729        session_ends = 0; 
     730         
     731        transport_errors = 0; 
     732        num_sessions = 0; 
     733        num_finals = 0; 
     734        num_end = 0; 
     735        session_errors = 0; 
     736 
     737        setup_testbed(NULL); 
     738         
     739        SmlError *error = NULL; 
     740        SmlTransport *server = smlTransportNew(SML_TRANSPORT_HTTP_SERVER, &error); 
     741        SmlTransport *client = smlTransportNew(SML_TRANSPORT_HTTP_CLIENT, &error); 
     742                 
     743        fail_unless(smlTransportSetConfigOption(client, "URL", "http://127.0.0.1:12004", &error), NULL); 
     744 
     745        fail_unless(smlTransportSetConfigOption(server, "PORT", "12004", &error), NULL); 
     746         
     747        managerTracker *clienttracker = g_malloc0(sizeof(managerTracker)); 
     748        SmlManager *clientmanager = clienttracker->manager = smlManagerNew(client, &error); 
     749        smlManagerSetEventCallback(clienttracker->manager, _manager_event, clienttracker); 
     750        managerTracker *servertracker = g_malloc0(sizeof(managerTracker)); 
     751        SmlManager *servermanager = servertracker->manager = smlManagerNew(server, &error); 
     752        smlManagerSetEventCallback(servertracker->manager, _manager_event, servertracker); 
     753        smlManagerSetLocalMaxMsgSize(servertracker->manager, TEST_DEFAULT_MAX_MSG_SIZE); 
     754        smlManagerSetLocalMaxObjSize(servertracker->manager, TEST_DEFAULT_MAX_OBJ_SIZE); 
     755         
     756        fail_unless(smlTransportInitialize(client, &error), NULL); 
     757        fail_unless(smlTransportInitialize(server, &error), NULL); 
     758 
     759        fail_unless(smlManagerStart(clientmanager, &error), NULL); 
     760        fail_unless(error == NULL, NULL); 
     761        fail_unless(smlManagerStart(servermanager, &error), NULL); 
     762        fail_unless(error == NULL, NULL); 
     763 
     764        SmlLocation *loc = smlLocationNew("test", NULL, &error); 
     765        fail_unless(loc != NULL, NULL); 
     766        fail_unless(error == NULL, NULL); 
     767         
     768        SmlLocation *loc1 = smlLocationNew("test1", NULL, &error); 
     769        fail_unless(loc1 != NULL, NULL); 
     770        fail_unless(error == NULL, NULL); 
     771         
     772        SmlLocation *loc2 = smlLocationNew("test2", NULL, &error); 
     773        fail_unless(loc2 != NULL, NULL); 
     774        fail_unless(error == NULL, NULL); 
     775         
     776        SmlLocation *loc3 = smlLocationNew("test3", NULL, &error); 
     777        fail_unless(loc3 != NULL, NULL); 
     778        fail_unless(error == NULL, NULL); 
     779         
     780        clienttracker->ds[0] = smlDsClientNew(SML_ELEMENT_TEXT_VCARD, loc1, loc1, &error); 
     781        clienttracker->ds[1] = smlDsClientNew(SML_ELEMENT_TEXT_VCAL, loc2, loc2, &error); 
     782        clienttracker->ds[2] = smlDsClientNew(SML_ELEMENT_TEXT_PLAIN, loc3, loc3, &error); 
     783        smlDsServerRegister(clienttracker->ds[0], clientmanager, &error); 
     784        smlDsServerRegister(clienttracker->ds[1], clientmanager, &error); 
     785        smlDsServerRegister(clienttracker->ds[2], clientmanager, &error); 
     786                                 
     787        servertracker->ds[0] = smlDsServerNew(SML_ELEMENT_TEXT_VCARD, loc1, &error); 
     788        servertracker->ds[1] = smlDsServerNew(SML_ELEMENT_TEXT_VCAL, loc2, &error); 
     789        servertracker->ds[2] = smlDsServerNew(SML_ELEMENT_TEXT_PLAIN, loc3, &error); 
     790        smlDsServerSetConnectCallback(servertracker->ds[0], _recv_init_alert, servertracker); 
     791        smlDsServerSetConnectCallback(servertracker->ds[1], _recv_init_alert, servertracker); 
     792        smlDsServerSetConnectCallback(servertracker->ds[2], _recv_init_alert, servertracker); 
     793        smlDsServerRegister(servertracker->ds[0], servermanager, &error); 
     794        smlDsServerRegister(servertracker->ds[1], servermanager, &error); 
     795        smlDsServerRegister(servertracker->ds[2], servermanager, &error); 
     796         
     797        smlLocationUnref(loc1); 
     798        smlLocationUnref(loc2); 
     799        smlLocationUnref(loc3); 
     800         
     801        /* The authenticator */ 
     802        SmlAuthenticator *auth = smlAuthNew(&error); 
     803        smlAuthSetEnable(auth, FALSE); 
     804        smlAuthRegister(auth, clientmanager, &error); 
     805         
     806        /* The authenticator */ 
     807        SmlAuthenticator *auth2 = smlAuthNew(&error); 
     808        smlAuthSetEnable(auth2, FALSE); 
     809        smlAuthRegister(auth2, servermanager, &error); 
     810         
     811        clienttracker->session = smlSessionNew(SML_SESSION_TYPE_CLIENT, SML_MIMETYPE_XML, SML_VERSION_12, SML_PROTOCOL_SYNCML, loc, loc, NULL, 0, &error); 
     812         
     813        fail_unless(smlManagerSessionAdd(clientmanager, clienttracker->session, NULL, &error), NULL); 
     814        fail_unless(error == NULL, NULL); 
     815         
     816        smlLocationUnref(loc); 
     817         
     818        clienttracker->dssessions[0] = smlDsServerSendAlert(clienttracker->ds[0], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     819        clienttracker->dssessions[1] = smlDsServerSendAlert(clienttracker->ds[1], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     820        clienttracker->dssessions[2] = smlDsServerSendAlert(clienttracker->ds[2], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     821         
     822        fail_unless(smlSessionFlush(clienttracker->session, TRUE, &error), NULL); 
     823        fail_unless(error == NULL, NULL); 
     824         
     825        while (init_alerts_received < 3 || num_sessions < 2) { 
     826                smlManagerDispatch(servermanager); 
     827                smlManagerDispatch(clientmanager); 
     828                usleep(100); 
     829                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     830        } 
     831         
     832        smlDsSessionGetAlert(servertracker->dssessions[0], _recv_alert, GINT_TO_POINTER(1)); 
     833        smlDsSessionGetAlert(servertracker->dssessions[1], _recv_alert, GINT_TO_POINTER(1)); 
     834        smlDsSessionGetAlert(servertracker->dssessions[2], _recv_alert, GINT_TO_POINTER(1)); 
     835         
     836        smlDsSessionSendAlert(servertracker->dssessions[0], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     837        smlDsSessionSendAlert(servertracker->dssessions[1], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     838        smlDsSessionSendAlert(servertracker->dssessions[2], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     839         
     840        fail_unless(servertracker->session != NULL, NULL); 
     841        fail_unless(smlSessionFlush(servertracker->session, TRUE, &error), NULL); 
     842         
     843        smlDsSessionGetAlert(clienttracker->dssessions[0], _recv_alert, GINT_TO_POINTER(1)); 
     844        smlDsSessionGetAlert(clienttracker->dssessions[1], _recv_alert, GINT_TO_POINTER(1)); 
     845        smlDsSessionGetAlert(clienttracker->dssessions[2], _recv_alert, GINT_TO_POINTER(1)); 
     846         
     847        while (alerts_received < 6) { 
     848                smlDsSessionDispatch(servertracker->dssessions[0]); 
     849                smlDsSessionDispatch(servertracker->dssessions[1]); 
     850                smlDsSessionDispatch(servertracker->dssessions[2]); 
     851                 
     852                smlDsSessionDispatch(clienttracker->dssessions[0]); 
     853                smlDsSessionDispatch(clienttracker->dssessions[1]); 
     854                smlDsSessionDispatch(clienttracker->dssessions[2]); 
     855                 
     856                smlManagerDispatch(servermanager); 
     857                smlManagerDispatch(clientmanager); 
     858                usleep(100); 
     859                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     860        } 
     861         
     862        const char *content_types[] = {SML_ELEMENT_TEXT_VCARD, SML_ELEMENT_TEXT_VCAL, SML_ELEMENT_TEXT_PLAIN}; 
     863        int k = 0; 
     864        for (k = 0; k < 3; k++) 
     865        { 
     866                smlDsSessionSendSync(clienttracker->dssessions[k], num_changes, _sync_reply, GINT_TO_POINTER(1), &error); 
     867         
     868                int i = 0; 
     869                for (i = 0; i < num_items; i++) { 
     870                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_ADD, "uid", "data", 4, content_types[k], _add_reply, GINT_TO_POINTER(2), &error), NULL); 
     871                        fail_unless(error == NULL, NULL); 
     872                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_REPLACE, "uid", "newdata", 7, content_types[k], _modify_reply, GINT_TO_POINTER(1), &error), NULL); 
     873                        fail_unless(error == NULL, NULL); 
     874                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_DELETE, "uid", NULL, 0, content_types[k], _delete_reply, GINT_TO_POINTER(1), &error), NULL); 
     875                        fail_unless(error == NULL, NULL); 
     876                } 
     877 
     878                smlDsSessionCloseSync(clienttracker->dssessions[k], &error); 
     879        } 
     880         
     881        fail_unless(smlSessionFlush(clienttracker->session, TRUE, &error), NULL); 
     882         
     883        smlDsSessionGetSync(servertracker->dssessions[0], _recv_sync, GINT_TO_POINTER(1)); 
     884        smlDsSessionGetSync(servertracker->dssessions[1], _recv_sync, GINT_TO_POINTER(1)); 
     885        smlDsSessionGetSync(servertracker->dssessions[2], _recv_sync, GINT_TO_POINTER(1)); 
     886        smlDsSessionGetChanges(servertracker->dssessions[0], _recv_changes, GINT_TO_POINTER(1)); 
     887        smlDsSessionGetChanges(servertracker->dssessions[1], _recv_changes, GINT_TO_POINTER(1)); 
     888        smlDsSessionGetChanges(servertracker->dssessions[2], _recv_changes, GINT_TO_POINTER(1)); 
     889         
     890        while (syncs_received < 3 || adds_received < num_items * 3 || deletes_received < num_items * 3 || modifies_received < num_items * 3) { 
     891                smlDsSessionDispatch(servertracker->dssessions[0]); 
     892                smlDsSessionDispatch(servertracker->dssessions[1]); 
     893                smlDsSessionDispatch(servertracker->dssessions[2]); 
     894                 
     895                smlDsSessionDispatch(clienttracker->dssessions[0]); 
     896                smlDsSessionDispatch(clienttracker->dssessions[1]); 
     897                smlDsSessionDispatch(clienttracker->dssessions[2]); 
     898                 
     899                smlManagerDispatch(servermanager); 
     900                smlManagerDispatch(clientmanager); 
     901                usleep(100); 
     902                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     903        } 
     904         
     905        for (k = 0; k < 3; k++) 
     906        { 
     907                smlDsSessionSendSync(servertracker->dssessions[k], num_changes, _sync_reply, GINT_TO_POINTER(1), &error); 
     908 
     909                int i = 0;       
     910                for (i = 0; i < num_items; i++) { 
     911                        fail_unless(smlDsSessionQueueChange(servertracker->dssessions[k], SML_CHANGE_ADD, "uid", "data", 4, content_types[k], _add_reply, GINT_TO_POINTER(1), &error), NULL); 
     912                        fail_unless(error == NULL, NULL); 
     913                        fail_unless(smlDsSessionQueueChange(servertracker->dssessions[k], SML_CHANGE_REPLACE, "uid", "newdata", 7, content_types[k], _modify_reply, GINT_TO_POINTER(1), &error), NULL); 
     914                        fail_unless(error == NULL, NULL); 
     915                        fail_unless(smlDsSessionQueueChange(servertracker->dssessions[k], SML_CHANGE_DELETE, "uid", NULL, 0, content_types[k], _delete_reply, GINT_TO_POINTER(1), &error), NULL); 
     916                        fail_unless(error == NULL, NULL); 
     917                } 
     918 
     919                smlDsSessionCloseSync(servertracker->dssessions[k], &error); 
     920        } 
     921         
     922        fail_unless(smlSessionFlush(servertracker->session, TRUE, &error), NULL); 
     923         
     924        smlDsSessionGetSync(clienttracker->dssessions[0], _recv_sync, GINT_TO_POINTER(1)); 
     925        smlDsSessionGetSync(clienttracker->dssessions[1], _recv_sync, GINT_TO_POINTER(1)); 
     926        smlDsSessionGetSync(clienttracker->dssessions[2], _recv_sync, GINT_TO_POINTER(1)); 
     927        smlDsSessionGetChanges(clienttracker->dssessions[0], _recv_changes, GINT_TO_POINTER(1)); 
     928        smlDsSessionGetChanges(clienttracker->dssessions[1], _recv_changes, GINT_TO_POINTER(1)); 
     929        smlDsSessionGetChanges(clienttracker->dssessions[2], _recv_changes, GINT_TO_POINTER(1)); 
     930         
     931        while (syncs_received < 6 || adds_received < num_items * 6 || deletes_received < num_items * 6 || modifies_received < num_items * 6) { 
     932                smlDsSessionDispatch(servertracker->dssessions[0]); 
     933                smlDsSessionDispatch(servertracker->dssessions[1]); 
     934                smlDsSessionDispatch(servertracker->dssessions[2]); 
     935                 
     936                smlDsSessionDispatch(clienttracker->dssessions[0]); 
     937                smlDsSessionDispatch(clienttracker->dssessions[1]); 
     938                smlDsSessionDispatch(clienttracker->dssessions[2]); 
     939                 
     940                smlManagerDispatch(servermanager); 
     941                smlManagerDispatch(clientmanager); 
     942                usleep(100); 
     943                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     944        } 
     945 
     946        int i = 0;       
     947        for (i = 0; i < num_items; i++) { 
     948                fail_unless(smlDsSessionQueueMap(clienttracker->dssessions[0], "uid", "newuid", &error), NULL); 
     949                fail_unless(smlDsSessionQueueMap(clienttracker->dssessions[1], "uid", "newuid", &error), NULL); 
     950                fail_unless(smlDsSessionQueueMap(clienttracker->dssessions[2], "uid", "newuid", &error), NULL); 
     951        } 
     952         
     953        smlDsSessionCloseMap(clienttracker->dssessions[0], _map_reply, GINT_TO_POINTER(1), &error); 
     954        smlDsSessionCloseMap(clienttracker->dssessions[1], _map_reply, GINT_TO_POINTER(1), &error); 
     955        smlDsSessionCloseMap(clienttracker->dssessions[2], _map_reply, GINT_TO_POINTER(1), &error); 
     956         
     957        fail_unless(smlSessionFlush(clienttracker->session, TRUE, &error), NULL); 
     958         
     959        while (delete_replies_received < num_items * 6) { 
     960                smlDsSessionDispatch(servertracker->dssessions[0]); 
     961                smlDsSessionDispatch(servertracker->dssessions[1]); 
     962                smlDsSessionDispatch(servertracker->dssessions[2]); 
     963                 
     964                smlDsSessionDispatch(clienttracker->dssessions[0]); 
     965                smlDsSessionDispatch(clienttracker->dssessions[1]); 
     966                smlDsSessionDispatch(clienttracker->dssessions[2]); 
     967                 
     968                smlManagerDispatch(servermanager); 
     969                smlManagerDispatch(clientmanager); 
     970                usleep(100); 
     971                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     972        } 
     973         
     974        fail_unless(servertracker->session != NULL, NULL); 
     975        fail_unless(smlSessionEnd(servertracker->session, &error), NULL); 
     976        fail_unless(error == NULL, NULL); 
     977        smlSessionUnref(servertracker->session); 
     978        smlSessionUnref(clienttracker->session); 
     979         
     980        while (num_end < 2 || replies_received < 15 || num_finals < 6) { 
     981                smlManagerDispatch(servermanager); 
     982                smlManagerDispatch(clientmanager); 
     983                usleep(100); 
     984                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     985        } 
     986         
     987        fail_unless(init_alerts_received == 3, NULL); 
     988        fail_unless(alerts_received == 6, NULL); 
     989        fail_unless(syncs_received == 6, NULL); 
     990        fail_unless(sync_ends_received == 0, NULL); 
     991        fail_unless(changes_received == 0, NULL); 
     992        fail_unless(replies_received == 15, NULL); 
     993        fail_unless(adds_received == num_items * 6, NULL); 
     994        fail_unless(add_replies_received == num_items * 6, NULL); 
     995        fail_unless(deletes_received == num_items * 6, NULL); 
     996        fail_unless(delete_replies_received == num_items * 6, NULL); 
     997        fail_unless(modifies_received == num_items * 6, NULL); 
     998        fail_unless(modify_replies_received == num_items * 6, NULL); 
     999        fail_unless(transport_errors == 0, NULL); 
     1000        fail_unless(num_sessions == 2, NULL); 
     1001        fail_unless(num_finals == 6, NULL); 
     1002        fail_unless(num_end == 2, NULL); 
     1003        fail_unless(session_errors == 0, NULL); 
     1004         
     1005         
     1006        smlDsSessionUnref(clienttracker->dssessions[0]); 
     1007        smlDsSessionUnref(clienttracker->dssessions[1]); 
     1008        smlDsSessionUnref(clienttracker->dssessions[2]); 
     1009         
     1010        smlDsSessionUnref(servertracker->dssessions[0]); 
     1011        smlDsSessionUnref(servertracker->dssessions[1]); 
     1012        smlDsSessionUnref(servertracker->dssessions[2]); 
     1013         
     1014        smlDsServerFree(clienttracker->ds[0]); 
     1015        smlDsServerFree(clienttracker->ds[1]); 
     1016        smlDsServerFree(clienttracker->ds[2]); 
     1017         
     1018        smlDsServerFree(servertracker->ds[0]); 
     1019        smlDsServerFree(servertracker->ds[1]); 
     1020        smlDsServerFree(servertracker->ds[2]); 
     1021         
     1022        smlAuthFree(auth); 
     1023        smlAuthFree(auth2); 
     1024         
     1025        g_free(clienttracker); 
     1026        g_free(servertracker); 
     1027         
     1028        smlManagerStop(clientmanager); 
     1029        smlManagerStop(servermanager); 
     1030         
     1031        smlManagerFree(clientmanager); 
     1032        smlManagerFree(servermanager); 
     1033         
     1034        fail_unless(smlTransportFinalize(server, &error), NULL); 
     1035        fail_unless(smlTransportFinalize(client, &error), NULL); 
     1036         
     1037        smlTransportFree(server); 
     1038        smlTransportFree(client); 
     1039
     1040END_TEST 
     1041 
     1042/* client -- 3 * alert ---> server 
     1043 * server -- statuses, 3 * alert ---> client 
     1044 * client -- statuses, num * add, num * replace, num * delete ---> server 
     1045 * server -- statuses ---> client 
     1046 */ 
     1047START_TEST (sync_multi_conf_from_devinf) 
     1048
     1049        int num_items = 100; 
     1050        num_changes = 3 * num_items; 
     1051 
     1052        init_alerts_received = 0; 
     1053        alerts_received = 0; 
     1054        syncs_received = 0; 
     1055        sync_ends_received = 0; 
     1056        changes_received = 0; 
     1057        replies_received = 0; 
     1058        adds_received = 0; 
     1059        add_replies_received = 0; 
     1060        deletes_received = 0; 
     1061        delete_replies_received = 0; 
     1062        modifies_received = 0; 
     1063        modify_replies_received = 0; 
     1064        session_ends = 0; 
     1065         
     1066        transport_errors = 0; 
     1067        num_sessions = 0; 
     1068        num_finals = 0; 
     1069        num_end = 0; 
     1070        session_errors = 0; 
     1071 
     1072        setup_testbed(NULL); 
     1073         
     1074        SmlError *error = NULL; 
     1075        SmlTransport *server = smlTransportNew(SML_TRANSPORT_HTTP_SERVER, &error); 
     1076        SmlTransport *client = smlTransportNew(SML_TRANSPORT_HTTP_CLIENT, &error); 
     1077         
     1078        fail_unless(smlTransportSetConfigOption(client, "URL", "http://127.0.0.1:12004", &error), NULL); 
     1079 
     1080        fail_unless(smlTransportSetConfigOption(server, "PORT", "12004", &error), NULL); 
     1081         
     1082        managerTracker *clienttracker = g_malloc0(sizeof(managerTracker)); 
     1083        SmlManager *clientmanager = clienttracker->manager = smlManagerNew(client, &error); 
     1084        smlManagerSetEventCallback(clienttracker->manager, _manager_event, clienttracker); 
     1085        managerTracker *servertracker = g_malloc0(sizeof(managerTracker)); 
     1086        SmlManager *servermanager = servertracker->manager = smlManagerNew(server, &error); 
     1087        smlManagerSetEventCallback(servertracker->manager, _manager_event, servertracker); 
     1088        smlManagerSetLocalMaxMsgSize(servertracker->manager, TEST_DEFAULT_MAX_MSG_SIZE); 
     1089        smlManagerSetLocalMaxObjSize(servertracker->manager, TEST_DEFAULT_MAX_OBJ_SIZE); 
     1090         
     1091        fail_unless(smlTransportInitialize(client, &error), NULL); 
     1092        fail_unless(smlTransportInitialize(server, &error), NULL); 
     1093 
     1094        fail_unless(smlManagerStart(clientmanager, &error), NULL); 
     1095        fail_unless(error == NULL, NULL); 
     1096        fail_unless(smlManagerStart(servermanager, &error), NULL); 
     1097        fail_unless(error == NULL, NULL); 
     1098 
     1099        SmlLocation *loc = smlLocationNew("test", NULL, &error); 
     1100        fail_unless(loc != NULL, NULL); 
     1101        fail_unless(error == NULL, NULL); 
     1102         
     1103        SmlLocation *loc1 = smlLocationNew("test1", NULL, &error); 
     1104        fail_unless(loc1 != NULL, NULL); 
     1105        fail_unless(error == NULL, NULL); 
     1106         
     1107        SmlLocation *loc2 = smlLocationNew("test2", NULL, &error); 
     1108        fail_unless(loc2 != NULL, NULL); 
     1109        fail_unless(error == NULL, NULL); 
     1110         
     1111        SmlLocation *loc3 = smlLocationNew("test3", NULL, &error); 
     1112        fail_unless(loc3 != NULL, NULL); 
     1113        fail_unless(error == NULL, NULL); 
     1114         
     1115        clienttracker->ds[0] = smlDsClientNew(SML_ELEMENT_TEXT_VCARD, loc1, loc1, &error); 
     1116        clienttracker->ds[1] = smlDsClientNew(SML_ELEMENT_TEXT_VCAL, loc2, loc2, &error); 
     1117        clienttracker->ds[2] = smlDsClientNew(SML_ELEMENT_TEXT_PLAIN, loc3, loc3, &error); 
     1118        smlDsServerRegister(clienttracker->ds[0], clientmanager, &error); 
     1119        smlDsServerRegister(clienttracker->ds[1], clientmanager, &error); 
     1120        smlDsServerRegister(clienttracker->ds[2], clientmanager, &error); 
     1121                                 
     1122        servertracker->ds[0] = smlDsServerNew(SML_ELEMENT_TEXT_VCARD, loc1, &error); 
     1123        servertracker->ds[1] = smlDsServerNew(SML_ELEMENT_TEXT_VCAL, loc2, &error); 
     1124        servertracker->ds[2] = smlDsServerNew(SML_ELEMENT_TEXT_PLAIN, loc3, &error); 
     1125        smlDsServerSetConnectCallback(servertracker->ds[0], _recv_init_alert, servertracker); 
     1126        smlDsServerSetConnectCallback(servertracker->ds[1], _recv_init_alert, servertracker); 
     1127        smlDsServerSetConnectCallback(servertracker->ds[2], _recv_init_alert, servertracker); 
     1128        smlDsServerRegister(servertracker->ds[0], servermanager, &error); 
     1129        smlDsServerRegister(servertracker->ds[1], servermanager, &error); 
     1130        smlDsServerRegister(servertracker->ds[2], servermanager, &error); 
     1131         
     1132        /* The devinf obj */ 
     1133        SmlDevInf *devinf = smlDevInfNew("LibSyncmML", SML_DEVINF_DEVTYPE_WORKSTATION, &error); 
     1134        smlDevInfSetSupportsNumberOfChanges(devinf, TRUE); 
     1135        smlDevInfSetSupportsLargeObjs(devinf, FALSE); 
     1136        smlDevInfSetSupportsUTC(devinf, FALSE); 
     1137        SmlDevInfAgent *clientagent = smlDevInfAgentNew(devinf, &error); 
     1138        smlDevInfAgentRegister(clientagent, clientmanager, &error); 
     1139 
     1140        /* And we also add the devinfo to the devinf agent */ 
     1141        SmlDevInfDataStore *datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc1), &error); 
     1142        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_VCARD, "2.1"); 
     1143        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_VCARD, "2.1"); 
     1144        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE); 
     1145        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE); 
     1146        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE); 
     1147        smlDevInfAddDataStore(devinf, datastore); 
     1148         
     1149        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc2), &error); 
     1150        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_VCAL, "2.0"); 
     1151        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_VCAL, "2.0"); 
     1152        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE); 
     1153        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE); 
     1154        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE); 
     1155        smlDevInfAddDataStore(devinf, datastore); 
     1156         
     1157        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc3), &error); 
     1158        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_PLAIN, "1.0"); 
     1159        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_PLAIN, "1.0"); 
     1160        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE); 
     1161        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE); 
     1162        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE); 
     1163        smlDevInfAddDataStore(devinf, datastore); 
     1164         
     1165        devinf = smlDevInfNew("LibSyncmML", SML_DEVINF_DEVTYPE_SERVER, &error); 
     1166        smlDevInfSetSupportsNumberOfChanges(devinf, TRUE); 
     1167        smlDevInfSetSupportsLargeObjs(devinf, TRUE); 
     1168        smlDevInfSetSupportsUTC(devinf, FALSE); 
     1169        SmlDevInfAgent *serveragent = smlDevInfAgentNew(devinf, &error); 
     1170        smlDevInfAgentRegister(serveragent, servermanager, &error); 
     1171         
     1172        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc1), &error); 
     1173        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_VCARD, "2.1"); 
     1174        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_VCARD, "2.1"); 
     1175        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE); 
     1176        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE); 
     1177        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE); 
     1178        smlDevInfAddDataStore(devinf, datastore); 
     1179         
     1180        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc2), &error); 
     1181        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_VCAL, "2.0"); 
     1182        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_VCAL, "2.0"); 
     1183        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE); 
     1184        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE); 
     1185        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE); 
     1186        smlDevInfAddDataStore(devinf, datastore); 
     1187         
     1188        datastore = smlDevInfDataStoreNew(smlLocationGetURI(loc3), &error); 
     1189        smlDevInfDataStoreSetRxPref(datastore, SML_ELEMENT_TEXT_PLAIN, "1.0"); 
     1190        smlDevInfDataStoreSetTxPref(datastore, SML_ELEMENT_TEXT_PLAIN, "1.0"); 
     1191        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_TWO_WAY, TRUE); 
     1192        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SLOW_SYNC, TRUE); 
     1193        smlDevInfDataStoreSetSyncCap(datastore, SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC, TRUE); 
     1194        smlDevInfAddDataStore(devinf, datastore); 
     1195         
     1196        smlLocationUnref(loc1); 
     1197        smlLocationUnref(loc2); 
     1198        smlLocationUnref(loc3); 
     1199         
     1200        /* The authenticator */ 
     1201        SmlAuthenticator *auth = smlAuthNew(&error); 
     1202        smlAuthSetEnable(auth, FALSE); 
     1203        smlAuthRegister(auth, clientmanager, &error); 
     1204         
     1205        /* The authenticator */ 
     1206        SmlAuthenticator *auth2 = smlAuthNew(&error); 
     1207        smlAuthSetEnable(auth2, FALSE); 
     1208        smlAuthRegister(auth2, servermanager, &error); 
     1209         
     1210        clienttracker->session = smlSessionNew(SML_SESSION_TYPE_CLIENT, SML_MIMETYPE_XML, SML_VERSION_12, SML_PROTOCOL_SYNCML, loc, loc, NULL, 0, &error); 
     1211        smlSessionSetLocalMaxMsgSize(clienttracker->session, TEST_DEFAULT_MAX_MSG_SIZE); 
     1212        fail_unless(smlSessionGetRemoteMaxObjSize(clienttracker->session) == 0, NULL); 
     1213        smlSessionSetLocalMaxObjSize(clienttracker->session, TEST_DEFAULT_MAX_OBJ_SIZE); 
     1214        fail_unless(smlSessionGetLocalMaxObjSize(clienttracker->session) == TEST_DEFAULT_MAX_OBJ_SIZE, NULL); 
     1215         
     1216        smlDevInfConfigureSession(devinf, clienttracker->session); 
     1217         
     1218        fail_unless(smlManagerSessionAdd(clientmanager, clienttracker->session, NULL, &error), NULL); 
     1219        fail_unless(error == NULL, NULL); 
     1220         
     1221        smlLocationUnref(loc); 
     1222         
     1223        clienttracker->dssessions[0] = smlDsServerSendAlert(clienttracker->ds[0], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     1224        clienttracker->dssessions[1] = smlDsServerSendAlert(clienttracker->ds[1], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     1225        clienttracker->dssessions[2] = smlDsServerSendAlert(clienttracker->ds[2], clienttracker->session, SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     1226         
     1227        fail_unless(smlDevInfAgentSendDevInf(clientagent, clienttracker->session, &error), NULL); 
     1228        fail_unless(error == NULL, NULL); 
     1229         
     1230        fail_unless(smlSessionFlush(clienttracker->session, TRUE, &error), NULL); 
     1231        fail_unless(error == NULL, NULL); 
     1232         
     1233        while (init_alerts_received < 3 || num_sessions < 2) { 
     1234                smlManagerDispatch(servermanager); 
     1235                smlManagerDispatch(clientmanager); 
     1236                usleep(100); 
     1237                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1238        } 
     1239         
     1240        fail_unless(smlSessionGetRemoteMaxMsgSize(servertracker->session) == TEST_DEFAULT_MAX_MSG_SIZE, NULL); 
     1241        fail_unless(smlSessionGetRemoteMaxObjSize(servertracker->session) == TEST_DEFAULT_MAX_OBJ_SIZE, 
     1242                g_strdup_printf("%u", smlSessionGetRemoteMaxObjSize(servertracker->session))); 
     1243        smlSessionSetLocalMaxMsgSize(servertracker->session, TEST_DEFAULT_MAX_MSG_SIZE); 
     1244        smlSessionSetLocalMaxObjSize(servertracker->session, TEST_DEFAULT_MAX_OBJ_SIZE); 
     1245         
     1246        smlDsSessionGetAlert(servertracker->dssessions[0], _recv_alert, GINT_TO_POINTER(1)); 
     1247        smlDsSessionGetAlert(servertracker->dssessions[1], _recv_alert, GINT_TO_POINTER(1)); 
     1248        smlDsSessionGetAlert(servertracker->dssessions[2], _recv_alert, GINT_TO_POINTER(1)); 
     1249         
     1250        while (alerts_received < 3 || !smlDevInfAgentGetDevInf(serveragent)) { 
     1251                smlDsSessionDispatch(servertracker->dssessions[0]); 
     1252                smlDsSessionDispatch(servertracker->dssessions[1]); 
     1253                smlDsSessionDispatch(servertracker->dssessions[2]); 
     1254                usleep(100); 
     1255                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1256        } 
     1257         
     1258        SmlDevInf *recvClientDevInf = smlDevInfAgentGetDevInf(serveragent); 
     1259        fail_unless(recvClientDevInf != NULL, NULL); 
     1260        fail_unless(smlDevInfNumDataStores(recvClientDevInf) == 3, NULL); 
     1261        fail_unless(smlDevInfSupportsNumberOfChanges(recvClientDevInf) == TRUE, NULL); 
     1262        fail_unless(smlDevInfSupportsLargeObjs(recvClientDevInf) == FALSE, NULL); 
     1263        fail_unless(smlDevInfSupportsUTC(recvClientDevInf) == FALSE, NULL); 
     1264         
     1265        fail_unless(smlDevInfAgentSendDevInf(serveragent, servertracker->session, &error), smlErrorPrint(&error)); 
     1266        fail_unless(error == NULL, smlErrorPrint(&error)); 
     1267         
     1268        smlDsSessionSendAlert(servertracker->dssessions[0], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     1269        smlDsSessionSendAlert(servertracker->dssessions[1], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     1270        smlDsSessionSendAlert(servertracker->dssessions[2], SML_ALERT_TWO_WAY, "last", "next", _alert_reply, GINT_TO_POINTER(1), &error); 
     1271         
     1272        fail_unless(servertracker->session != NULL, NULL); 
     1273        fail_unless(smlSessionFlush(servertracker->session, TRUE, &error), NULL); 
     1274         
     1275        smlDsSessionGetAlert(clienttracker->dssessions[0], _recv_alert, GINT_TO_POINTER(1)); 
     1276        smlDsSessionGetAlert(clienttracker->dssessions[1], _recv_alert, GINT_TO_POINTER(1)); 
     1277        smlDsSessionGetAlert(clienttracker->dssessions[2], _recv_alert, GINT_TO_POINTER(1)); 
     1278         
     1279        while (alerts_received < 6) { 
     1280                smlDsSessionDispatch(servertracker->dssessions[0]); 
     1281                smlDsSessionDispatch(servertracker->dssessions[1]); 
     1282                smlDsSessionDispatch(servertracker->dssessions[2]); 
     1283                 
     1284                smlDsSessionDispatch(clienttracker->dssessions[0]); 
     1285                smlDsSessionDispatch(clienttracker->dssessions[1]); 
     1286                smlDsSessionDispatch(clienttracker->dssessions[2]); 
     1287                 
     1288                smlManagerDispatch(servermanager); 
     1289                smlManagerDispatch(clientmanager); 
     1290                usleep(100); 
     1291                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1292        } 
     1293         
     1294        fail_unless(smlSessionGetRemoteMaxMsgSize(clienttracker->session) == TEST_DEFAULT_MAX_MSG_SIZE, NULL); 
     1295        fail_unless(smlSessionGetRemoteMaxObjSize(servertracker->session) == TEST_DEFAULT_MAX_OBJ_SIZE, NULL); 
     1296         
     1297        SmlDevInf *recvServerDevInf = smlDevInfAgentGetDevInf(clientagent); 
     1298        fail_unless(recvServerDevInf != NULL, NULL); 
     1299        fail_unless(smlDevInfNumDataStores(recvServerDevInf) == 3, NULL); 
     1300        fail_unless(smlDevInfSupportsNumberOfChanges(recvServerDevInf) == TRUE, NULL); 
     1301        fail_unless(smlDevInfSupportsLargeObjs(recvServerDevInf) == TRUE, NULL); 
     1302        fail_unless(smlDevInfSupportsUTC(recvServerDevInf) == FALSE, NULL); 
     1303         
     1304        const char *content_types[] = {SML_ELEMENT_TEXT_VCARD, SML_ELEMENT_TEXT_VCAL, SML_ELEMENT_TEXT_PLAIN}; 
     1305        int k = 0; 
     1306        for (k = 0; k < 3; k++) 
     1307        { 
     1308                smlDsSessionSendSync(clienttracker->dssessions[k], num_changes, _sync_reply, GINT_TO_POINTER(1), &error); 
     1309         
     1310                int i = 0; 
     1311                for (i = 0; i < num_items; i++) { 
     1312                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_ADD, "uid", "data", 4, content_types[k], _add_reply, GINT_TO_POINTER(2), &error), NULL); 
     1313                        fail_unless(error == NULL, NULL); 
     1314                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_REPLACE, "uid", "newdata", 7, content_types[k], _modify_reply, GINT_TO_POINTER(1), &error), NULL); 
     1315                        fail_unless(error == NULL, NULL); 
     1316                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_DELETE, "uid", NULL, 0, content_types[k], _delete_reply, GINT_TO_POINTER(1), &error), NULL); 
     1317                        fail_unless(error == NULL, NULL); 
     1318                } 
     1319 
     1320                smlDsSessionCloseSync(clienttracker->dssessions[k], &error); 
     1321        } 
     1322         
     1323        fail_unless(smlSessionFlush(clienttracker->session, TRUE, &error), NULL); 
     1324         
     1325        smlDsSessionGetSync(servertracker->dssessions[0], _recv_sync, GINT_TO_POINTER(1)); 
     1326        smlDsSessionGetSync(servertracker->dssessions[1], _recv_sync, GINT_TO_POINTER(1)); 
     1327        smlDsSessionGetSync(servertracker->dssessions[2], _recv_sync, GINT_TO_POINTER(1)); 
     1328        smlDsSessionGetChanges(servertracker->dssessions[0], _recv_changes, GINT_TO_POINTER(1)); 
     1329        smlDsSessionGetChanges(servertracker->dssessions[1], _recv_changes, GINT_TO_POINTER(1)); 
     1330        smlDsSessionGetChanges(servertracker->dssessions[2], _recv_changes, GINT_TO_POINTER(1)); 
     1331         
     1332        while (syncs_received < 3 || adds_received < num_items * 3 || deletes_received < num_items * 3 || modifies_received < num_items * 3) { 
     1333                smlDsSessionDispatch(servertracker->dssessions[0]); 
     1334                smlDsSessionDispatch(servertracker->dssessions[1]); 
     1335                smlDsSessionDispatch(servertracker->dssessions[2]); 
     1336                 
     1337                smlDsSessionDispatch(clienttracker->dssessions[0]); 
     1338                smlDsSessionDispatch(clienttracker->dssessions[1]); 
     1339                smlDsSessionDispatch(clienttracker->dssessions[2]); 
     1340                 
     1341                smlManagerDispatch(servermanager); 
     1342                smlManagerDispatch(clientmanager); 
     1343                usleep(100); 
     1344                fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1345        } 
     1346         
     1347        for (k = 0; k < 3; k++) 
     1348        { 
     1349                smlDsSessionSendSync(servertracker->dssessions[k], num_changes, _sync_reply, GINT_TO_POINTER(1), &error); 
     1350 
     1351                int i = 0;       
     1352                for (i = 0; i < num_items; i++) { 
     1353                        fail_unless(smlDsSessionQueueChange(servertracker->dssessions[k], SML_CHANGE_ADD, "uid", "data", 4, content_types[k], _add_reply, GINT_TO_POINTER(1), &error), NULL); 
     1354                        fail_unless(error == NULL, NULL); 
     1355                        fail_unless(smlDsSessionQueueChange(servertracker->dssessions[k], SML_CHANGE_REPLACE, "uid", "n