Changeset 504

Show
Ignore:
Timestamp:
07/22/08 14:19:34 (4 months ago)
Author:
bellmich
Message:

several fixes to make the framework more flexible

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/tests/mobiles/nokia_6230.c

    r502 r504  
    11/* Description of the mobile: 
    22 * 
    3  * Mobile:          Nokia 6230 (without i) 
     3 * Mobile:          Nokia 6230 (without i - old Nokia Series 40) 
    44 * FirmwareVersion: V 05.50 
    55 * SoftwareVersion: V 05.50 
    …… 
    1717 
    1818#include "obex_mobile.c" 
     19#include <glib.h> 
    1920 
    2021const char *mobile_name = "Nokia 6230 (without i)"; 
    2122unsigned int max_msg_size = 65535; 
    2223unsigned int max_obj_size = 65535; 
     24SmlBool useTimestamp = FALSE; 
    2325 
    2426const char *source = "PC Suite"; 
    2527const char *target = "/"; 
    26 const char *locVcal = NULL; 
    27 const char *locVcard = "contacts"; 
     28 
     29const char *locList[] = {"contacts", SML_ELEMENT_TEXT_VCARD, 
     30                         NULL, NULL}; 
    2831 
    2932const char *libsyncml_msg_notification = "<?xml version=\"1.0\"?>\n<!DOCTYPE SyncML PUBLIC \"-//SYNCML//DTD SyncML 1.1//EN\" \"http://www.syncml.org/docs/syncml_represent_v11_20020213.dtd\"><SyncML xmlns=\"SYNCML:SYNCML1.1\"><SyncHdr><VerDTD>1.1</VerDTD><VerProto>SyncML/1.1</VerProto><SessionID>11376387627789510945</SessionID><MsgID>1</MsgID><Target><LocURI>/</LocURI></Target><Source><LocURI>PC Suite</LocURI></Source><Meta><MaxMsgSize xmlns=\"syncml:metinf\">65535</MaxMsgSize></Meta></SyncHdr>\n<SyncBody><Alert><CmdID>1</CmdID><Data>206</Data><Item><Source><LocURI>contacts</LocURI></Source><Meta><Type xmlns=\"syncml:metinf\">text/x-vcard</Type></Meta></Item>\n</Alert><Final></Final></SyncBody></SyncML>"; 

  • trunk/tests/mobiles/obex_mobile.c

    r503 r504  
    2222 
    2323#define NUM_SESSIONS 30 
    24 #define OBEX_PORT "10101" 
    2524 
    2625/* mobile status variables */ 
    …… 
    7271extern unsigned int max_obj_size; 
    7372 
     73/* usually the OMA DS server can detect this from the client's alert */ 
     74extern SmlBool useTimestamp; 
     75 
    7476extern const char *target; 
    7577extern const char *source; 
    76 extern const char *locVcal; 
    77 extern const char *locVcard; 
     78 
     79extern const char *locList[]; 
    7880 
    7981extern const char *mobile_name; 

  • trunk/tests/mobiles/obex_mobile_ds_client.c

    r503 r504  
    2222 
    2323#define NUM_SESSIONS 30 
    24 #define OBEX_PORT "10101" 
    2524 
    2625/* ************************************ 
    …… 
    203202} 
    204203 
     204char *obex_port; 
    205205void obex_mobile_connect() 
    206206{ 
    207207        SmlError *error = NULL; 
    208208        mobile_tsp = smlTransportNew(SML_TRANSPORT_OBEX_SERVER, &error); 
    209          
    210         fail_unless(smlTransportSetConfigOption(mobile_tsp, "PORT", OBEX_PORT, &error), NULL); 
     209 
     210        obex_port = g_strdup_printf("%d", g_random_int_range(10001, 19999)); 
     211         
     212        fail_unless(smlTransportSetConfigOption(mobile_tsp, "PORT", obex_port, &error), NULL); 
    211213        fail_unless(smlTransportSetConnectionType(mobile_tsp, SML_TRANSPORT_CONNECTION_TYPE_NET, &error), NULL); 
    212214 

  • trunk/tests/mobiles/obex_mobile_ds_server.c

    r503 r504  
    2222 
    2323#define NUM_SESSIONS 30 
    24 #define OBEX_PORT "10101" 
    2524 
    2625/* ************************************ 
    …… 
    4746unsigned int libsyncml_syncs_received = 0; 
    4847unsigned int libsyncml_adds_received = 0; 
    49  
    50 int num_changes; 
     48unsigned int libsyncml_finals_received = 0; 
     49 
    5150SmlError *eventError = NULL; 
    5251 
    …… 
    8281                        break; 
    8382                case SML_MANAGER_SESSION_FINAL: 
     83                        libsyncml_finals_received++; 
     84                        if (TEST_LIBSYNCML_STATE_RECEIVED_DATASTORE_SESSION) 
     85                                libsyncml_state = TEST_LIBSYNCML_STATE_RECEIVED_ALERT; 
    8486                        break; 
    8587                case SML_MANAGER_SESSION_END: 
    …… 
    99101} 
    100102 
    101 static void _recv_init_alert(SmlDsSession *dsession, void *userdata) 
    102 { 
    103         smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, dsession, userdata); 
    104         managerTracker *tracker = userdata; 
    105  
    106         fail_unless(tracker == libsyncml_tracker, "wrong tracker in userdata"); 
    107          
    108         if (tracker->ds[0] == smlDsSessionGetServer(dsession)) 
    109                 tracker->dssessions[0] = dsession; 
    110         else if (tracker->ds[1] == smlDsSessionGetServer(dsession)) 
    111                 tracker->dssessions[1] = dsession; 
    112         else if (tracker->ds[2] == smlDsSessionGetServer(dsession)) 
    113                 tracker->dssessions[2] = dsession; 
    114  
    115         if ( (!locVcard || tracker->dssessions[0]) && 
    116              (!locVcal || tracker->dssessions[1])) 
    117         { 
    118                 libsyncml_state = TEST_LIBSYNCML_STATE_RECEIVED_DATASTORE_SESSION; 
    119         } 
    120          
    121         smlDsSessionRef(dsession); 
    122          
    123         smlTrace(TRACE_EXIT, "%s", __func__); 
    124 } 
     103GList *dsSessionList = NULL; 
     104SmlDevInfAgent *libsyncml_agent = NULL; 
     105extern char *obex_port; 
    125106 
    126107void obex_libsyncml_connect() 
    …… 
    133114                 smlErrorPrint(&error)); 
    134115        fail_unless( 
    135                 smlTransportSetConfigOption(libsyncml_tsp, "PORT", OBEX_PORT, &error), 
     116                smlTransportSetConfigOption(libsyncml_tsp, "PORT", obex_port, &error), 
    136117                smlErrorPrint(&error)); 
    137118        fail_unless( 
    …… 
    159140} 
    160141 
    161 void obex_libsyncml_send_san() 
    162 { 
    163         SmlError *error = NULL; 
    164          
    165         /* actually we only test server alerted syncs (SyncML 1.1) */ 
    166         SmlNotification *san = smlNotificationNew(SML_SAN_VERSION_11, SML_SAN_UIMODE_USER, SML_SAN_INITIATOR_SERVER, 65535, source, target, SML_MIMETYPE_XML, &error); 
    167         fail_unless(san != NULL, NULL); 
    168         fail_unless(error == NULL, NULL); 
    169         smlNotificationSetManager(san, libsyncml_manager); 
    170  
    171         if (locVcard) 
    172         { 
    173                 SmlLocation *loc1 = smlLocationNew(locVcard, NULL, &error); 
    174                 fail_unless(loc1 != NULL, NULL); 
    175                 fail_unless(error == NULL, NULL); 
    176                 libsyncml_tracker->ds[0] = smlDsServerNew(SML_ELEMENT_TEXT_VCARD, loc1, &error); 
    177                 smlDsServerSetConnectCallback(libsyncml_tracker->ds[0], _recv_init_alert, libsyncml_tracker); 
    178                 smlDsServerRegister(libsyncml_tracker->ds[0], libsyncml_manager, &error); 
    179                 smlLocationUnref(loc1); 
    180                 fail_unless(smlDsServerAddSan(libsyncml_tracker->ds[0], san, &error), NULL); 
    181                 fail_unless(error == NULL, NULL); 
    182         } 
    183  
    184         if (locVcal) 
    185         { 
    186                 SmlLocation *loc2 = smlLocationNew(locVcal, NULL, &error); 
    187                 fail_unless(loc2 != NULL, NULL); 
    188                 fail_unless(error == NULL, NULL); 
    189                 libsyncml_tracker->ds[1] = smlDsServerNew(SML_ELEMENT_TEXT_VCAL, loc2, &error); 
    190                 smlDsServerSetConnectCallback(libsyncml_tracker->ds[1], _recv_init_alert, libsyncml_tracker); 
    191                 smlDsServerRegister(libsyncml_tracker->ds[1], libsyncml_manager, &error); 
    192                 smlLocationUnref(loc2); 
    193                 fail_unless(smlDsServerAddSan(libsyncml_tracker->ds[1], san, &error), NULL); 
    194                 fail_unless(error == NULL, NULL); 
    195         } 
    196          
    197         fail_unless(smlNotificationSend(san, libsyncml_tsp, &error), NULL); 
    198         fail_unless(error == NULL, NULL); 
    199  
    200         /* num_session < 1 guarantees that the all events of the manager are dispatched */ 
    201         while (mobile_state != TEST_MOBILE_STATE_WAIT_FOR_ALERT || num_sessions < 1) { 
    202                 smlManagerDispatch(libsyncml_manager); 
    203                 usleep(100); 
    204                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    205         } 
    206          
    207         fail_unless(libsyncml_tracker != NULL, NULL); 
    208         libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_ALERT; 
     142static void _alert_reply(SmlSession *dsession, SmlStatus *status, void *userdata) 
     143{ 
     144        smlTrace(TRACE_ENTRY, "%s()", __func__); 
     145         
     146        fail_unless(status != NULL, NULL); 
     147         
     148        if (GPOINTER_TO_INT(userdata) == 1) { 
     149                fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_SUCCESS, NULL); 
     150        } else { 
     151                fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_FATAL, NULL); 
     152        } 
     153         
     154        smlTrace(TRACE_EXIT, "%s", __func__); 
    209155} 
    210156 
    …… 
    212158{ 
    213159        smlTrace(TRACE_ENTRY, "%s(%p, %i, %s, %s, %p)", __func__, dsession, type, last, next, userdata); 
     160 
     161        SmlDsSession *oldSession = userdata; 
     162        // FIXME: Why do we get a new DsSession here !? 
     163        // fail_unless(dsession != userdata, "Used DsSession != Registered DsSession"); 
    214164 
    215165        /* The test performs a slow sync alert */ 
    …… 
    220170        fail_unless(next != NULL, NULL); 
    221171 
    222         libsyncml_state = TEST_LIBSYNCML_STATE_RECEIVED_ALERT; 
     172        SmlError *error = NULL; 
     173        if (useTimestamp) 
     174                smlDsSessionSendAlert(oldSession, SML_ALERT_SLOW_SYNC, "0", "20080101T123456Z", _alert_reply, GINT_TO_POINTER(1), &error); 
     175        else 
     176                smlDsSessionSendAlert(oldSession, SML_ALERT_SLOW_SYNC, "0", "12345", _alert_reply, GINT_TO_POINTER(1), &error); 
    223177         
    224178        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    229183} 
    230184 
    231 static void _alert_reply(SmlSession *dsession, SmlStatus *status, void *userdata) 
     185static void _sync_reply(SmlSession *dsession, SmlStatus *status, void *userdata) 
    232186{ 
    233187        smlTrace(TRACE_ENTRY, "%s()", __func__); 
    …… 
    244198} 
    245199 
    246 SmlDevInfAgent *libsyncml_agent = NULL; 
    247 void obex_libsyncml_send_alert() 
    248 { 
    249         SmlError *error = NULL; 
    250  
    251         while(libsyncml_state != TEST_LIBSYNCML_STATE_RECEIVED_DATASTORE_SESSION || num_sessions < 2) 
    252         { 
    253                 smlManagerDispatch(libsyncml_manager); 
    254                 usleep(100); 
    255                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    256         } 
    257  
    258         if (locVcard) 
    259         { 
    260                 libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_ALERT; 
    261                 smlDsSessionGetAlert(libsyncml_tracker->dssessions[0], _recv_alert, GINT_TO_POINTER(1)); 
    262                 while(libsyncml_state != TEST_LIBSYNCML_STATE_RECEIVED_ALERT) 
    263                 { 
    264                         smlManagerDispatch(libsyncml_manager); 
    265                         usleep(100); 
    266                         fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    267                 } 
    268                 smlDsSessionSendAlert(libsyncml_tracker->dssessions[0], SML_ALERT_SLOW_SYNC, "last", "12345", _alert_reply, GINT_TO_POINTER(1), &error); 
    269         } 
    270  
    271         if (locVcal) 
    272         { 
    273                 libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_ALERT; 
    274                 smlDsSessionGetAlert(libsyncml_tracker->dssessions[1], _recv_alert, GINT_TO_POINTER(1)); 
    275                 while(libsyncml_state != TEST_LIBSYNCML_STATE_RECEIVED_ALERT) 
    276                 { 
    277                         smlManagerDispatch(libsyncml_manager); 
    278                         usleep(100); 
    279                         fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    280                 } 
    281                 smlDsSessionSendAlert(libsyncml_tracker->dssessions[1], SML_ALERT_SLOW_SYNC, "last", "12345", _alert_reply, GINT_TO_POINTER(1), &error); 
    282         } 
    283  
    284         SmlDevInf *devinf = smlDevInfNew("LibSyncmML", SML_DEVINF_DEVTYPE_WORKSTATION, &error); 
    285         smlDevInfSetSupportsNumberOfChanges(devinf, TRUE); 
    286         smlDevInfSetSupportsLargeObjs(devinf, TRUE); 
    287         smlDevInfSetSupportsUTC(devinf, TRUE); 
    288         libsyncml_agent = smlDevInfAgentNew(devinf, &error); 
    289         smlDevInfAgentRegister(libsyncml_agent, libsyncml_manager, &error); 
    290         fail_unless(smlDevInfAgentRequestDevInf(libsyncml_agent, libsyncml_tracker->session, &error), NULL); 
    291  
    292         fail_unless(libsyncml_tracker->session != NULL, NULL); 
    293         fail_unless(smlSessionFlush(libsyncml_tracker->session, TRUE, &error), NULL); 
    294  
    295         libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_SYNC; 
    296  
    297         while(mobile_state == TEST_MOBILE_STATE_WAIT_FOR_ALERT) 
    298         { 
    299                 smlManagerDispatch(libsyncml_manager); 
    300                 usleep(100); 
    301                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    302         } 
    303 } 
    304  
    305200static void _recv_sync(SmlDsSession *dsession, unsigned int numChanges, void *userdata) 
    306201{ 
    …… 
    310205        fail_unless(devinf != NULL, NULL); 
    311206        if (smlDevInfSupportsNumberOfChanges(devinf))    
    312                 fail_unless(numChanges == num_changes, NULL); 
     207                fail_unless(numChanges, NULL); 
    313208        libsyncml_syncs_received++; 
     209 
     210        SmlError *error = NULL; 
     211        smlDsSessionSendSync(dsession, 0, _sync_reply, GINT_TO_POINTER(1), &error); 
     212        smlDsSessionCloseSync(dsession, &error); 
    314213                 
    315214        smlTrace(TRACE_EXIT, "%s", __func__); 
    …… 
    333232} 
    334233 
    335 static void _sync_reply(SmlSession *dsession, SmlStatus *status, void *userdata) 
    336 { 
    337         smlTrace(TRACE_ENTRY, "%s()", __func__); 
    338          
    339         fail_unless(status != NULL, NULL); 
    340          
    341         if (GPOINTER_TO_INT(userdata) == 1) { 
    342                 fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_SUCCESS, NULL); 
    343         } else { 
    344                 fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_FATAL, NULL); 
    345         } 
    346          
    347         smlTrace(TRACE_EXIT, "%s", __func__); 
    348 } 
    349  
    350 static void _add_reply(SmlDsSession *session, SmlStatus *status, const char *newuid, void *userdata) 
    351 { 
    352         smlTrace(TRACE_ENTRY, "%s(%p, %p, %s, %p)", __func__, session, status, newuid, userdata); 
    353          
    354         fail_unless(status != NULL, NULL); 
    355         fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_SUCCESS, NULL); 
    356         fail_unless(GPOINTER_TO_INT(userdata) == 1 || GPOINTER_TO_INT(userdata) == 2, NULL); 
    357  
    358         if (GPOINTER_TO_INT(userdata) == 1) 
    359                 fail_unless(!strcmp(newuid, "newuid"), NULL); 
    360         else 
    361                 fail_unless(newuid == NULL, NULL); 
    362          
    363         smlTrace(TRACE_EXIT, "%s", __func__); 
     234static void _recv_init_alert(SmlDsSession *dsession, void *userdata) 
     235{ 
     236        smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, dsession, userdata); 
     237        managerTracker *tracker = userdata; 
     238 
     239        fail_unless(tracker == libsyncml_tracker, "wrong tracker in userdata"); 
     240 
     241        printf("received init alert for %s\n", smlDsServerGetContentType(smlDsSessionGetServer(dsession))); 
     242 
     243        // store the DsSession 
     244        if (tracker->ds[0] == smlDsSessionGetServer(dsession)) 
     245                tracker->dssessions[0] = dsession; 
     246        else if (tracker->ds[1] == smlDsSessionGetServer(dsession)) 
     247                tracker->dssessions[1] = dsession; 
     248        dsSessionList = g_list_append(dsSessionList, dsession); 
     249 
     250        // register the callbacks to handle alerts from client 
     251        smlDsSessionGetAlert(dsession, _recv_alert, dsession); 
     252        smlDsSessionGetSync(dsession, _recv_sync, GINT_TO_POINTER(1)); 
     253        smlDsSessionGetChanges(dsession, _recv_changes, GINT_TO_POINTER(1)); 
     254 
     255        // set the correct state 
     256        if ( tracker->dssessions[0] && 
     257             (locList[2] == NULL || tracker->dssessions[1])) 
     258        { 
     259                libsyncml_state = TEST_LIBSYNCML_STATE_RECEIVED_DATASTORE_SESSION; 
     260        } 
     261         
     262        smlDsSessionRef(dsession); 
     263         
     264        smlTrace(TRACE_EXIT, "%s", __func__); 
     265} 
     266 
     267void obex_libsyncml_send_san() 
     268{ 
     269        SmlError *error = NULL; 
     270         
     271        /* actually we only test server alerted syncs (SyncML 1.1) */ 
     272        SmlNotification *san = smlNotificationNew(SML_SAN_VERSION_11, SML_SAN_UIMODE_USER, SML_SAN_INITIATOR_SERVER, 65535, source, target, SML_MIMETYPE_XML, &error); 
     273        fail_unless(san != NULL, NULL); 
     274        fail_unless(error == NULL, NULL); 
     275        smlNotificationSetManager(san, libsyncml_manager); 
     276 
     277        int i = 0; 
     278        for (i = 0; locList[2*i] != NULL; i++) 
     279        { 
     280                SmlLocation *loc = smlLocationNew(locList[2*i], NULL, &error); 
     281                fail_unless(loc != NULL, NULL); 
     282                fail_unless(error == NULL, NULL); 
     283                libsyncml_tracker->ds[i] = smlDsServerNew(locList[2*i+1], loc, &error); 
     284                smlDsServerSetConnectCallback(libsyncml_tracker->ds[i], _recv_init_alert, libsyncml_tracker); 
     285                smlDsServerRegister(libsyncml_tracker->ds[i], libsyncml_manager, &error); 
     286                smlLocationUnref(loc); 
     287                fail_unless(smlDsServerAddSan(libsyncml_tracker->ds[i], san, &error), NULL); 
     288                fail_unless(error == NULL, NULL); 
     289        } 
     290         
     291        fail_unless(smlNotificationSend(san, libsyncml_tsp, &error), NULL); 
     292        fail_unless(error == NULL, NULL); 
     293 
     294        /* num_session < 1 guarantees that the all events of the manager are dispatched */ 
     295        while (mobile_state != TEST_MOBILE_STATE_WAIT_FOR_ALERT || num_sessions < 1) { 
     296                smlManagerDispatch(libsyncml_manager); 
     297                usleep(100); 
     298                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
     299        } 
     300         
     301        fail_unless(libsyncml_tracker != NULL, NULL); 
     302        libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_ALERT; 
     303} 
     304 
     305void obex_libsyncml_send_alert() 
     306{ 
     307        SmlError *error = NULL; 
     308 
     309        while(( 
     310               libsyncml_state != TEST_LIBSYNCML_STATE_RECEIVED_DATASTORE_SESSION && 
     311               libsyncml_state != TEST_LIBSYNCML_STATE_RECEIVED_ALERT 
     312              ) || num_sessions < 2) 
     313        { 
     314                smlManagerDispatch(libsyncml_manager); 
     315                usleep(100); 
     316                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
     317        } 
     318 
     319        while(libsyncml_state != TEST_LIBSYNCML_STATE_RECEIVED_ALERT) 
     320        { 
     321                smlManagerDispatch(libsyncml_manager); 
     322                usleep(100); 
     323                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
     324        } 
     325 
     326        SmlDevInf *devinf = smlDevInfNew("LibSyncmML", SML_DEVINF_DEVTYPE_WORKSTATION, &error); 
     327        smlDevInfSetSupportsNumberOfChanges(devinf, TRUE); 
     328        smlDevInfSetSupportsLargeObjs(devinf, TRUE); 
     329        smlDevInfSetSupportsUTC(devinf, TRUE); 
     330        libsyncml_agent = smlDevInfAgentNew(devinf, &error); 
     331        smlDevInfAgentRegister(libsyncml_agent, libsyncml_manager, &error); 
     332        fail_unless(smlDevInfAgentRequestDevInf(libsyncml_agent, libsyncml_tracker->session, &error), NULL); 
     333 
     334        fail_unless(libsyncml_tracker->session != NULL, NULL); 
     335        fail_unless(smlSessionFlush(libsyncml_tracker->session, TRUE, &error), NULL); 
     336 
     337        libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_SYNC; 
     338 
     339        while(mobile_state == TEST_MOBILE_STATE_WAIT_FOR_ALERT) 
     340        { 
     341                smlManagerDispatch(libsyncml_manager); 
     342                usleep(100); 
     343                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
     344        } 
    364345} 
    365346 
    …… 
    368349        unsigned int datastores = 0; 
    369350        int num_items = 4; 
    370         num_changes = num_items; 
    371         SmlError *error = NULL; 
    372  
    373         if (locVcard) { 
    374                 smlDsSessionGetSync(libsyncml_tracker->dssessions[0], _recv_sync, GINT_TO_POINTER(1)); 
    375                 smlDsSessionGetChanges(libsyncml_tracker->dssessions[0], _recv_changes, GINT_TO_POINTER(1)); 
    376                 datastores++; 
    377         } 
    378         if (locVcal) { 
    379                 smlDsSessionGetSync(libsyncml_tracker->dssessions[1], _recv_sync, GINT_TO_POINTER(1)); 
    380                 smlDsSessionGetChanges(libsyncml_tracker->dssessions[1], _recv_changes, GINT_TO_POINTER(1)); 
    381                 datastores++; 
    382         } 
    383                  
     351        SmlError *error = NULL; 
     352 
     353        // make sure that the sync was handled 
     354        smlManagerDispatch(libsyncml_manager); 
     355 
    384356        while (libsyncml_syncs_received < datastores || 
    385                libsyncml_adds_received < num_items * datastores) 
    386         { 
    387                 if (locVcard) 
    388                         smlDsSessionDispatch(libsyncml_tracker->dssessions[0]); 
    389                 if (locVcal) 
    390                         smlDsSessionDispatch(libsyncml_tracker->dssessions[1]); 
     357               libsyncml_finals_received < 2) 
     358        { 
     359                int i = 0; 
     360                for (i = 0; i < g_list_length(dsSessionList); i++) 
     361                { 
     362                        smlDsSessionDispatch(g_list_nth_data(dsSessionList, i)); 
     363                } 
    391364                 
    392365                smlManagerDispatch(libsyncml_manager); 
    …… 
    399372        smlSessionUseNumberOfChanges(libsyncml_tracker->session, smlDevInfSupportsNumberOfChanges(devinf)); 
    400373 
    401         const char *content_types[] = {SML_ELEMENT_TEXT_VCARD, SML_ELEMENT_TEXT_VCAL, SML_ELEMENT_TEXT_PLAIN}; 
    402         int k = 0; 
    403         for (k = 0; k < datastores; k++) 
    404         { 
    405                 smlDsSessionSendSync(libsyncml_tracker->dssessions[k], 0, _sync_reply, GINT_TO_POINTER(1), &error); 
    406  
    407                 //int i = 0;     
    408                 //for (i = 0; i < num_items; i++) { 
    409                 //      fail_unless(smlDsSessionQueueChange(libsyncml_tracker->dssessions[k], SML_CHANGE_ADD, "uid", "data", 4, content_types[k], _add_reply, GINT_TO_POINTER(1), &error), NULL); 
    410                 //      fail_unless(error == NULL, NULL); 
    411                 //} 
    412  
    413                 smlDsSessionCloseSync(libsyncml_tracker->dssessions[k], &error); 
    414         } 
    415          
    416374        fail_unless(smlSessionFlush(libsyncml_tracker->session, TRUE, &error), NULL); 
    417375