Changeset 503

Show
Ignore:
Timestamp:
07/18/08 16:50:42 (4 months ago)
Author:
bellmich
Message:

splitted source base for mobile specific tests

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/tests/mobiles/obex_mobile.c

    r502 r503  
    2424#define OBEX_PORT "10101" 
    2525 
    26 /* ************************************ 
    27  * *********** OBEX SERVER ************ 
    28  * ************************************ 
    29  *         (mobile simulator) 
    30  */ 
    31  
    32 #include <libsyncml/sml_transport_internals.h> 
     26/* mobile status variables */ 
    3327 
    3428typedef enum { 
    …… 
    4539 
    4640SmlTestMobileStateType mobile_state = TEST_MOBILE_STATE_UNKNOWN; 
    47 unsigned int mobile_receives = 0; 
    48 unsigned int mobile_connect_done = 0; 
    49 unsigned int mobile_disconnect_done = 1; 
    50 SmlTransport *mobile_tsp = NULL; 
    5141 
    52 void obex_server_send(SmlLink *link, const char *data, unsigned int size) 
    53 { 
    54         SmlError *error = NULL; 
    55  
    56         SmlTransportData *tsp_data = smlTransportDataNew(g_strdup(data), size, SML_MIMETYPE_XML, FALSE, &error); 
    57         fail_unless(tsp_data != NULL, NULL); 
    58         fail_unless(error == NULL, NULL); 
    59  
    60         fail_unless(smlTransportSend(mobile_tsp, link, tsp_data, &error), smlErrorPrint(&error)); 
    61         fail_unless(error == NULL, NULL); 
    62          
    63         smlTransportDataDeref(tsp_data); 
    64 } 
    65  
    66 SmlBool equal_messages(const char *now, unsigned int size, const char *expected) 
    67 { 
    68         smlTrace(TRACE_ENTRY, "%s", __func__); 
    69         GRegex *regex = NULL; 
    70         GError *error = NULL; 
    71         char *now_1; 
    72         char *now_2; 
    73         char *org_1; 
    74         char *org_2; 
    75  
    76         /* ignore SessionID */ 
    77  
    78         regex = g_regex_new("<SessionID>[0-9]+</SessionID>", 0, 0, &error); 
    79         fail_unless(regex != NULL, "SessionID filter cannot be established."); 
    80  
    81         now_1 = g_regex_replace_literal(regex, now, size, 
    82                         0, "<SessionID>2346</SessionID>", 0, 
    83                         &error); 
    84         fail_unless(now_1 != NULL, "Cannot filter SessionID from new message."); 
    85  
    86         org_1 = g_regex_replace_literal(regex, expected, strlen(expected), 
    87                         0, "<SessionID>2346</SessionID>", 0, 
    88                         &error); 
    89         fail_unless(org_1 != NULL, "Cannot filter SessionID from original message."); 
    90  
    91         g_regex_unref(regex); 
    92  
    93         /* ignore trailing whitespaces */ 
    94  
    95         regex = g_regex_new("[\\s\\n]*$", G_REGEX_DOLLAR_ENDONLY, 0, &error); 
    96         fail_unless(regex != NULL, "Trailing whitespace filter cannot be established."); 
    97  
    98         now_2 = g_regex_replace_literal(regex, now_1, strlen(now_1), 0, "", 0, &error); 
    99         fail_unless(now_2 != NULL, "Cannot filter trailing whitespaces from new message."); 
    100         smlSafeCFree(&now_1); 
    101  
    102         org_2 = g_regex_replace_literal(regex, org_1, strlen(org_1), 0, "", 0, &error); 
    103         fail_unless(org_2 != NULL, "Cannot filter trailing whitespaces from original message."); 
    104         smlSafeCFree(&org_1); 
    105  
    106         g_regex_unref(regex); 
    107  
    108         /* ignore newlines (not carriage return) */ 
    109  
    110         regex = g_regex_new(">\\n<", 0, 0, &error); 
    111         fail_unless(regex != NULL, "Useless newline filter cannot be established."); 
    112  
    113         now_1 = g_regex_replace_literal(regex, now_2, strlen(now_2), 0, "><", 0, &error); 
    114         fail_unless(now_1 != NULL, "Cannot filter useless newlines from new message."); 
    115         smlSafeCFree(&now_2); 
    116  
    117         org_1 = g_regex_replace_literal(regex, org_2, strlen(org_2), 0, "><", 0, &error); 
    118         fail_unless(org_1 != NULL, "Cannot filter useless newlines from original message."); 
    119         smlSafeCFree(&org_2); 
    120  
    121         g_regex_unref(regex); 
    122  
    123         /* ignore numbered next values */ 
    124  
    125         regex = g_regex_new("<Next xmlns=\"syncml:metinf\">[0-9]+</Next>", 0, 0, &error); 
    126         fail_unless(regex != NULL, "Numbered Next filter cannot be established."); 
    127  
    128         now_2 = g_regex_replace_literal(regex, now_1, strlen(now_1), 
    129                         0, "<Next xmlns=\"syncml:metinf\">1357</Next>", 0, &error); 
    130         fail_unless(now_2 != NULL, "Cannot filter numbered Next from new message."); 
    131         smlSafeCFree(&now_1); 
    132  
    133         org_2 = g_regex_replace_literal(regex, org_1, strlen(org_1), 
    134                         0, "<Next xmlns=\"syncml:metinf\">1357</Next>", 0, &error); 
    135         fail_unless(org_2 != NULL, "Cannot filter numbered Next from original message."); 
    136         smlSafeCFree(&org_1); 
    137  
    138         g_regex_unref(regex); 
    139  
    140         /* ignore timestamp next values */ 
    141  
    142         regex = g_regex_new("<Next xmlns=\"syncml:metinf\">[0-9]{8}T[0-9]{6}Z</Next>", 0, 0, &error); 
    143         fail_unless(regex != NULL, "Timestamp Next filter cannot be established."); 
    144  
    145         now_1 = g_regex_replace_literal(regex, now_2, strlen(now_2), 
    146                         0, "<Next xmlns=\"syncml:metinf\">20080101T140000Z</Next>", 0, &error); 
    147         fail_unless(now_1 != NULL, "Cannot filter timestamp Next from new message."); 
    148         smlSafeCFree(&now_2); 
    149  
    150         org_1 = g_regex_replace_literal(regex, org_2, strlen(org_2), 
    151                         0, "<Next xmlns=\"syncml:metinf\">20080101T140000Z</Next>", 0, &error); 
    152         fail_unless(org_1 != NULL, "Cannot filter timestamp Next from original message."); 
    153         smlSafeCFree(&org_2); 
    154  
    155         g_regex_unref(regex); 
    156  
    157         /* compare strings */ 
    158  
    159         SmlBool notEqual = strcmp(now_1, org_1); 
    160  
    161         if (notEqual) 
    162                 smlTrace(TRACE_INTERNAL, "%s: FAILED\n==>%s<==\n-----\n==>%s<==", __func__, now_1, org_1); 
    163         smlSafeCFree(&now_1); 
    164         smlSafeCFree(&org_1); 
    165  
    166         smlTrace(TRACE_EXIT, "%s - %d", __func__, (!notEqual)); 
    167         return (!notEqual); 
    168 } 
    169  
    170 /* This callback function makes the real work. */ 
     42/* supported messages */ 
    17143 
    17244extern const char *libsyncml_msg_notification; 
    …… 
    17850extern const char *libsyncml_msg_end; 
    17951 
    180 SmlBool _recv_server_event(SmlTransport *tsp, SmlLink *link, SmlTransportEventType type, SmlTransportData *data, SmlError *error, void *userdata) 
    181 { 
    182         smlTrace(TRACE_ENTRY, "%s()", __func__); 
    183                  
    184         switch (type) { 
    185                 case SML_TRANSPORT_EVENT_DATA: 
    186                         mobile_receives++; 
    187  
    188                         if (mobile_state == TEST_MOBILE_STATE_WAIT_FOR_NOTIFICATION) { 
    189                                 smlTrace(TRACE_INTERNAL, "%s: mobile received notification", __func__); 
    190                                 if (!equal_messages(data->data, data->size, libsyncml_msg_notification)) 
    191                                         fail("wrong notification message"); 
    192                                 mobile_state = TEST_MOBILE_STATE_WAIT_FOR_ALERT; 
    193                                 obex_server_send(link, mobile_msg_alert, strlen(mobile_msg_alert)); 
    194                         } else if (mobile_state == TEST_MOBILE_STATE_WAIT_FOR_ALERT) { 
    195                                 smlTrace(TRACE_INTERNAL, "%s: mobile received alert", __func__); 
    196                                 if (!equal_messages(data->data, data->size, libsyncml_msg_alert)) 
    197                                         fail("wrong alert message"); 
    198                                 mobile_state = TEST_MOBILE_STATE_WAIT_FOR_SYNC; 
    199                                 obex_server_send(link, mobile_msg_sync, strlen(mobile_msg_sync)); 
    200                         } else if (mobile_state == TEST_MOBILE_STATE_WAIT_FOR_SYNC) { 
    201                                 smlTrace(TRACE_INTERNAL, "%s: mobile received sync", __func__); 
    202                                 if (!equal_messages(data->data, data->size, libsyncml_msg_sync)) 
    203                                         fail("wrong sync message"); 
    204                                 mobile_state = TEST_MOBILE_STATE_WAIT_FOR_END; 
    205                                 obex_server_send(link, mobile_msg_map, strlen(mobile_msg_map)); 
    206                         } else if (mobile_state == TEST_MOBILE_STATE_WAIT_FOR_END) { 
    207                                 smlTrace(TRACE_INTERNAL, "%s: mobile received end", __func__); 
    208                                 if (!equal_messages(data->data, data->size, libsyncml_msg_end)) 
    209                                         fail("wrong end message"); 
    210                                 mobile_state = TEST_MOBILE_STATE_FINISHED; 
    211                                 smlTransportDisconnect(mobile_tsp, link, &error); 
    212                         } else { 
    213                                 fail("Unexpected mobile state."); 
    214                         } 
    215                         break; 
    216                 case SML_TRANSPORT_EVENT_CONNECT_DONE: 
    217                         g_atomic_int_inc(&mobile_connect_done); 
    218                         mobile_state = TEST_MOBILE_STATE_CONNECTED; 
    219                         fail_unless(libsyncml_msg_notification != NULL, "Missing notification message"); 
    220                         mobile_state = TEST_MOBILE_STATE_WAIT_FOR_NOTIFICATION; 
    221                         break; 
    222                 case SML_TRANSPORT_EVENT_DISCONNECT_DONE: 
    223                         g_atomic_int_inc(&mobile_disconnect_done); 
    224                         mobile_state = TEST_MOBILE_STATE_DISCONNECTED; 
    225                         break; 
    226                 default: 
    227                         fail(NULL); 
    228         } 
    229          
    230         smlTrace(TRACE_EXIT, "%s()", __func__); 
    231         return TRUE; 
    232 } 
    233  
    234 void obex_server_connect() 
    235 { 
    236         SmlError *error = NULL; 
    237         mobile_tsp = smlTransportNew(SML_TRANSPORT_OBEX_SERVER, &error); 
    238          
    239         fail_unless(smlTransportSetConfigOption(mobile_tsp, "PORT", OBEX_PORT, &error), NULL); 
    240         fail_unless(smlTransportSetConnectionType(mobile_tsp, SML_TRANSPORT_CONNECTION_TYPE_NET, &error), NULL); 
    241  
    242         fail_unless(smlTransportRunAsync(mobile_tsp, &error), NULL); 
    243         fail_unless(error == NULL, NULL); 
    244          
    245         fail_unless(smlTransportInitialize(mobile_tsp, &error), NULL); 
    246  
    247         smlTransportSetEventCallback(mobile_tsp, _recv_server_event, GINT_TO_POINTER(1)); 
    248 } 
    249  
    250 void obex_server_disconnect() 
    251 { 
    252         SmlError *error = NULL; 
    253         while (mobile_state != TEST_MOBILE_STATE_DISCONNECTED) 
    254         { 
    255                 usleep(100); 
    256         } 
    257         smlTransportStop(mobile_tsp); 
    258         fail_unless(smlTransportFinalize(mobile_tsp, &error), NULL); 
    259         smlTransportFree(mobile_tsp); 
    260 } 
    261  
    262 /* ************************************ 
    263  * *********** OBEX CLIENT ************ 
    264  * ************************************ 
    265  *          (libsyncml user) 
    266  */ 
    267  
    268 #include <libsyncml/objects/sml_ds_server.h> 
    269 #include <libsyncml/objects/sml_auth.h> 
    270 #include <libsyncml/objects/sml_devinf_obj.h> 
     52/* libsyncml status variables */ 
    27153 
    27254typedef enum { 
    …… 
    27456        TEST_LIBSYNCML_STATE_CONNECTED, 
    27557        TEST_LIBSYNCML_STATE_WAIT_FOR_ALERT, 
     58        TEST_LIBSYNCML_STATE_RECEIVED_DATASTORE_SESSION, 
     59        TEST_LIBSYNCML_STATE_RECEIVED_ALERT, 
    27660        TEST_LIBSYNCML_STATE_WAIT_FOR_SYNC, 
    27761        TEST_LIBSYNCML_STATE_WAIT_FOR_MAP, 
    …… 
    28064        TEST_LIBSYNCML_STATE_FAILED 
    28165} SmlTestLibsyncmlStateType; 
     66 
    28267SmlTestLibsyncmlStateType libsyncml_state = TEST_LIBSYNCML_STATE_UNKNOWN; 
    28368 
    284 typedef struct managerTracker { 
    285         SmlManager *manager; 
    286         SmlSession *session; 
    287         SmlDsSession *dssessions[NUM_SESSIONS]; 
    288         SmlDsServer *ds[2]; 
    289 } managerTracker; 
    290  
    291 SmlTransport *libsyncml_tsp = NULL; 
    292 managerTracker *libsyncml_tracker = NULL; 
    293 SmlManager *libsyncml_manager = NULL; 
    294  
    295 unsigned int libsyncml_san_alerts_received = 0; 
    296 unsigned int libsyncml_sans_received = 0; 
    297 unsigned int libsyncml_alerts_received = 0; 
    298 unsigned int libsyncml_alert_replies_received = 0; 
    299 unsigned int libsyncml_syncs_received = 0; 
    300 unsigned int libsyncml_adds_received = 0; 
    301 unsigned int libsyncml_sync_replies_received = 0; 
    302 unsigned int libsyncml_add_replies_received = 0; 
    303  
    304 /* This is a sync test only and not a test of large object support. 
    305  * Therefore all commands must be put into one message. 
    306  * This means one message per package. 
    307  */ 
    308 int num_changes; 
    309 SmlError *eventError = NULL; 
    310  
    311 unsigned int transport_errors = 0; 
    312 unsigned int num_sessions = 0; 
    313 unsigned int num_finals = 0; 
    314 unsigned int num_end = 0; 
    315 unsigned int session_errors = 0; 
    316  
    317 static void _manager_event(SmlManager *manager, SmlManagerEventType type, SmlSession *session, SmlError *error, void *userdata) 
    318 { 
    319         smlTrace(TRACE_ENTRY, "%s(%p, %i, %p, %p, %p)", __func__, manager, type, session, error, userdata); 
    320         managerTracker *tracker = userdata; 
    321         smlAssert(manager); 
    322         smlAssert(userdata); 
    323          
    324         switch (type) { 
    325                 case SML_MANAGER_SESSION_ESTABLISHED: 
    326                 case SML_MANAGER_SESSION_FLUSH: 
    327                         break; 
    328                 case SML_MANAGER_CONNECT_DONE: 
    329                         libsyncml_state = TEST_LIBSYNCML_STATE_CONNECTED; 
    330                         break; 
    331                 case SML_MANAGER_DISCONNECT_DONE: 
    332                         libsyncml_state = TEST_LIBSYNCML_STATE_DISCONNECTED; 
    333                         break; 
    334                 case SML_MANAGER_TRANSPORT_ERROR: 
    335                         smlTrace(TRACE_INTERNAL, "%s - error: %s", __func__, smlErrorPrint(&error)); 
    336                         eventError = error; 
    337                         smlErrorRef(&eventError); 
    338                         transport_errors++; 
    339                         break; 
    340                 case SML_MANAGER_SESSION_NEW: 
    341                         smlAssert(session); 
    342                         tracker->session = session; 
    343                         num_sessions++; 
    344                         smlSessionRef(session); 
    345                         break; 
    346                 case SML_MANAGER_SESSION_FINAL: 
    347                         num_finals++; 
    348                         break; 
    349                 case SML_MANAGER_SESSION_END: 
    350                         num_end++; 
    351                         break; 
    352                 case SML_MANAGER_SESSION_ERROR: 
    353                 case SML_MANAGER_SESSION_WARNING: 
    354                         smlTrace(TRACE_INTERNAL, "%s - error: %s", __func__, smlErrorPrint(&error)); 
    355                         eventError = error; 
    356                         smlErrorRef(&eventError); 
    357                         session_errors++; 
    358                         break; 
    359                 default: 
    360                         fail(); 
    361                         break; 
    362         } 
    363          
    364         smlTrace(TRACE_EXIT, "%s", __func__); 
    365 } 
    366  
    367 static void _recv_init_alert(SmlDsSession *dsession, void *userdata) 
    368 { 
    369         smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, dsession, userdata); 
    370         managerTracker *tracker = userdata; 
    371  
    372         fail_unless(tracker == libsyncml_tracker, "wrong tracker in userdata"); 
    373          
    374         if (tracker->ds[0] == smlDsSessionGetServer(dsession)) 
    375                 tracker->dssessions[0] = dsession; 
    376         else if (tracker->ds[1] == smlDsSessionGetServer(dsession)) 
    377                 tracker->dssessions[1] = dsession; 
    378         else if (tracker->ds[2] == smlDsSessionGetServer(dsession)) 
    379                 tracker->dssessions[2] = dsession; 
    380          
    381         smlDsSessionRef(dsession); 
    382          
    383         libsyncml_san_alerts_received++; 
    384          
    385         smlTrace(TRACE_EXIT, "%s", __func__); 
    386 } 
     69/* external parameters */ 
    38770 
    38871extern unsigned int max_msg_size; 
    38972extern unsigned int max_obj_size; 
    390 void obex_client_connect() 
    391 { 
    392         SmlError *error = NULL; 
    393  
    394         libsyncml_tsp = smlTransportNew(SML_TRANSPORT_OBEX_CLIENT, &error); 
    395         fail_unless( 
    396                 smlTransportSetConnectionType(libsyncml_tsp, SML_TRANSPORT_CONNECTION_TYPE_NET, &error), 
    397                  smlErrorPrint(&error)); 
    398         fail_unless( 
    399                 smlTransportSetConfigOption(libsyncml_tsp, "PORT", OBEX_PORT, &error), 
    400                 smlErrorPrint(&error)); 
    401         fail_unless( 
    402                 smlTransportSetConfigOption(libsyncml_tsp, "URL", "127.0.0.1", &error), 
    403                 smlErrorPrint(&error)); 
    404          
    405         libsyncml_tracker = g_malloc0(sizeof(managerTracker)); 
    406         libsyncml_manager = libsyncml_tracker->manager = smlManagerNew(libsyncml_tsp, &error); 
    407         smlManagerSetEventCallback(libsyncml_tracker->manager, _manager_event, libsyncml_tracker); 
    408         smlManagerSetLocalMaxMsgSize(libsyncml_tracker->manager, max_msg_size); 
    409         smlManagerSetLocalMaxObjSize(libsyncml_tracker->manager, max_obj_size); 
    410          
    411         fail_unless(smlManagerStart(libsyncml_manager, &error), NULL); 
    412         fail_unless(error == NULL, NULL); 
    413  
    414         fail_unless(smlTransportInitialize(libsyncml_tsp, &error), smlErrorPrint(&error)); 
    415  
    416         /* The authenticator */ 
    417         SmlAuthenticator *auth = smlAuthNew(&error); 
    418         smlAuthSetEnable(auth, FALSE); 
    419         smlAuthRegister(auth, libsyncml_manager, &error); 
    420          
    421         fail_unless(smlTransportConnect(libsyncml_tsp, &error), NULL); 
    422         fail_unless(error == NULL, NULL); 
    423 } 
    42473 
    42574extern const char *target; 
    …… 
    42776extern const char *locVcal; 
    42877extern const char *locVcard; 
    429 void obex_client_send_san() 
    430 { 
    431         SmlError *error = NULL; 
    432          
    433         /* actually we only test server alerted syncs (SyncML 1.1) */ 
    434         SmlNotification *san = smlNotificationNew(SML_SAN_VERSION_11, SML_SAN_UIMODE_USER, SML_SAN_INITIATOR_SERVER, 65535, source, target, SML_MIMETYPE_XML, &error); 
    435         fail_unless(san != NULL, NULL); 
    436         fail_unless(error == NULL, NULL); 
    437         smlNotificationSetManager(san, libsyncml_manager); 
    43878 
    439         if (locVcard) 
    440         { 
    441                 SmlLocation *loc1 = smlLocationNew(locVcard, NULL, &error); 
    442                 fail_unless(loc1 != NULL, NULL); 
    443                 fail_unless(error == NULL, NULL); 
    444                 libsyncml_tracker->ds[0] = smlDsServerNew(SML_ELEMENT_TEXT_VCARD, loc1, &error); 
    445                 smlDsServerSetConnectCallback(libsyncml_tracker->ds[0], _recv_init_alert, libsyncml_tracker); 
    446                 smlDsServerRegister(libsyncml_tracker->ds[0], libsyncml_manager, &error); 
    447                 smlLocationUnref(loc1); 
    448                 fail_unless(smlDsServerAddSan(libsyncml_tracker->ds[0], san, &error), NULL); 
    449                 fail_unless(error == NULL, NULL); 
    450         } 
     79extern const char *mobile_name; 
    45180 
    452         if (locVcal) 
    453         { 
    454                 SmlLocation *loc2 = smlLocationNew(locVcal, NULL, &error); 
    455                 fail_unless(loc2 != NULL, NULL); 
    456                 fail_unless(error == NULL, NULL); 
    457                 libsyncml_tracker->ds[1] = smlDsServerNew(SML_ELEMENT_TEXT_VCAL, loc2, &error); 
    458                 smlDsServerSetConnectCallback(libsyncml_tracker->ds[1], _recv_init_alert, libsyncml_tracker); 
    459                 smlDsServerRegister(libsyncml_tracker->ds[1], libsyncml_manager, &error); 
    460                 smlLocationUnref(loc2); 
    461                 fail_unless(smlDsServerAddSan(libsyncml_tracker->ds[1], san, &error), NULL); 
    462                 fail_unless(error == NULL, NULL); 
    463         } 
    464          
    465         fail_unless(smlNotificationSend(san, libsyncml_tsp, &error), NULL); 
    466         fail_unless(error == NULL, NULL); 
    467          
    468         while (num_sessions < 2) { 
    469                 smlManagerDispatch(libsyncml_manager); 
    470                 usleep(100); 
    471                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    472         } 
    473          
    474         fail_unless(libsyncml_tracker != NULL, NULL); 
    475  
    476         libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_ALERT; 
    477 } 
    478  
    479 static SmlBool _recv_alert(SmlDsSession *dsession, SmlAlertType type, const char *last, const char *next, void *userdata) 
    480 { 
    481         smlTrace(TRACE_ENTRY, "%s(%p, %i, %s, %s, %p)", __func__, dsession, type, last, next, userdata); 
    482  
    483         /* The test performs a slow sync alert */ 
    484          
    485         if (type != SML_ALERT_SLOW_SYNC) 
    486                 fail_unless(last != NULL, NULL); 
    487  
    488         fail_unless(next != NULL, NULL); 
    489          
    490         libsyncml_alerts_received++; 
    491          
    492         smlTrace(TRACE_EXIT, "%s", __func__); 
    493         if (type != SML_ALERT_SLOW_SYNC) 
    494                 return FALSE; 
    495         else 
    496                 return TRUE; 
    497 } 
    498  
    499 static void _alert_reply(SmlSession *dsession, SmlStatus *status, void *userdata) 
    500 { 
    501         smlTrace(TRACE_ENTRY, "%s()", __func__); 
    502          
    503         fail_unless(status != NULL, NULL); 
    504          
    505         if (GPOINTER_TO_INT(userdata) == 1) { 
    506                 fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_SUCCESS, NULL); 
    507         } else { 
    508                 fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_FATAL, NULL); 
    509         } 
    510          
    511         libsyncml_alert_replies_received++; 
    512          
    513         smlTrace(TRACE_EXIT, "%s", __func__); 
    514 } 
    515  
    516 SmlDevInfAgent *libsyncml_agent = NULL; 
    517 void obex_client_send_alert() 
    518 { 
    519         SmlError *error = NULL; 
    520  
    521         if (locVcard) 
    522         { 
    523                 smlDsSessionGetAlert(libsyncml_tracker->dssessions[0], _recv_alert, GINT_TO_POINTER(1)); 
    524                 smlDsSessionSendAlert(libsyncml_tracker->dssessions[0], SML_ALERT_SLOW_SYNC, "last", "12345", _alert_reply, GINT_TO_POINTER(1), &error); 
    525         } 
    526         if (locVcal) 
    527         { 
    528                 smlDsSessionGetAlert(libsyncml_tracker->dssessions[1], _recv_alert, GINT_TO_POINTER(1)); 
    529                 smlDsSessionSendAlert(libsyncml_tracker->dssessions[1], SML_ALERT_SLOW_SYNC, "last", "12345", _alert_reply, GINT_TO_POINTER(1), &error); 
    530         } 
    531  
    532         extern unsigned int max_obj_size; 
    533         extern SmlBool utc; 
    534  
    535         SmlDevInf *devinf = smlDevInfNew("LibSyncmML", SML_DEVINF_DEVTYPE_WORKSTATION, &error); 
    536         smlDevInfSetSupportsNumberOfChanges(devinf, TRUE); 
    537         smlDevInfSetSupportsLargeObjs(devinf, TRUE); 
    538         smlDevInfSetSupportsUTC(devinf, TRUE); 
    539         libsyncml_agent = smlDevInfAgentNew(devinf, &error); 
    540         smlDevInfAgentRegister(libsyncml_agent, libsyncml_manager, &error); 
    541         fail_unless(smlDevInfAgentRequestDevInf(libsyncml_agent, libsyncml_tracker->session, &error), NULL); 
    542  
    543         fail_unless(libsyncml_tracker->session != NULL, NULL); 
    544         fail_unless(smlSessionFlush(libsyncml_tracker->session, TRUE, &error), NULL); 
    545  
    546         libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_SYNC; 
    547  
    548         while(mobile_state == TEST_MOBILE_STATE_WAIT_FOR_ALERT) 
    549         { 
    550                 smlManagerDispatch(libsyncml_manager); 
    551                 usleep(100); 
    552                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    553         } 
    554 } 
    555  
    556 static void _recv_sync(SmlDsSession *dsession, unsigned int numChanges, void *userdata) 
    557 { 
    558         smlTrace(TRACE_ENTRY, "%s()", __func__); 
    559  
    560         SmlDevInf *devinf = smlDevInfAgentGetDevInf(libsyncml_agent); 
    561         fail_unless(devinf != NULL, NULL); 
    562         if (smlDevInfSupportsNumberOfChanges(devinf))    
    563                 fail_unless(numChanges == num_changes, NULL); 
    564         libsyncml_syncs_received++; 
    565                  
    566         smlTrace(TRACE_EXIT, "%s", __func__); 
    567 } 
    568  
    569 static SmlBool _recv_changes(SmlDsSession *dsession, SmlChangeType type, const char *uid, char *data, unsigned int size, const char *contenttype, void *userdata, SmlError **error) 
    570 { 
    571         smlTrace(TRACE_ENTRY, "%s(%p, %i, %s, %s, %i, %s, %p, %p)", __func__, dsession, type, uid, data, size, contenttype, userdata, error); 
    572  
    573         if (type == SML_CHANGE_ADD) { 
    574                 libsyncml_adds_received++; 
    575         } else if (type == SML_CHANGE_REPLACE) { 
    576                 fail("Replace during SLOW-SYNC received"); 
    577         } else if (type == SML_CHANGE_DELETE) { 
    578                 fail("Delete during SLOW-SYNC received"); 
    579         } else 
    580                 fail(NULL); 
    581          
    582         smlTrace(TRACE_EXIT, "%s", __func__); 
    583         return TRUE; 
    584 } 
    585  
    586 static void _sync_reply(SmlSession *dsession, SmlStatus *status, void *userdata) 
    587 { 
    588         smlTrace(TRACE_ENTRY, "%s()", __func__); 
    589          
    590         fail_unless(status != NULL, NULL); 
    591          
    592         if (GPOINTER_TO_INT(userdata) == 1) { 
    593                 fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_SUCCESS, NULL); 
    594         } else { 
    595                 fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_FATAL, NULL); 
    596         } 
    597          
    598         libsyncml_sync_replies_received++; 
    599          
    600         smlTrace(TRACE_EXIT, "%s", __func__); 
    601 } 
    602  
    603 static void _add_reply(SmlDsSession *session, SmlStatus *status, const char *newuid, void *userdata) 
    604 { 
    605         smlTrace(TRACE_ENTRY, "%s(%p, %p, %s, %p)", __func__, session, status, newuid, userdata); 
    606          
    607         fail_unless(status != NULL, NULL); 
    608         fail_unless(smlStatusGetClass(status) == SML_ERRORCLASS_SUCCESS, NULL); 
    609         fail_unless(GPOINTER_TO_INT(userdata) == 1 || GPOINTER_TO_INT(userdata) == 2, NULL); 
    610  
    611         if (GPOINTER_TO_INT(userdata) == 1) 
    612                 fail_unless(!strcmp(newuid, "newuid"), NULL); 
    613         else 
    614                 fail_unless(newuid == NULL, NULL); 
    615          
    616         libsyncml_add_replies_received++; 
    617  
    618         smlTrace(TRACE_EXIT, "%s", __func__); 
    619 } 
    620  
    621 void obex_client_send_sync() 
    622 { 
    623         unsigned int datastores = 0; 
    624         int num_items = 4; 
    625         num_changes = num_items; 
    626         SmlError *error = NULL; 
    627  
    628         if (locVcard) { 
    629                 smlDsSessionGetSync(libsyncml_tracker->dssessions[0], _recv_sync, GINT_TO_POINTER(1)); 
    630                 smlDsSessionGetChanges(libsyncml_tracker->dssessions[0], _recv_changes, GINT_TO_POINTER(1)); 
    631                 datastores++; 
    632         } 
    633         if (locVcal) { 
    634                 smlDsSessionGetSync(libsyncml_tracker->dssessions[1], _recv_sync, GINT_TO_POINTER(1)); 
    635                 smlDsSessionGetChanges(libsyncml_tracker->dssessions[1], _recv_changes, GINT_TO_POINTER(1)); 
    636                 datastores++; 
    637         } 
    638                  
    639         while (libsyncml_syncs_received < datastores || 
    640                libsyncml_adds_received < num_items * datastores) 
    641         { 
    642                 if (locVcard) 
    643                         smlDsSessionDispatch(libsyncml_tracker->dssessions[0]); 
    644                 if (locVcal) 
    645                         smlDsSessionDispatch(libsyncml_tracker->dssessions[1]); 
    646                  
    647                 smlManagerDispatch(libsyncml_manager); 
    648                 usleep(100); 
    649                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    650         } 
    651  
    652         SmlDevInf *devinf = smlDevInfAgentGetDevInf(libsyncml_agent); 
    653         fail_unless(devinf != NULL, NULL); 
    654         smlSessionUseNumberOfChanges(libsyncml_tracker->session, smlDevInfSupportsNumberOfChanges(devinf)); 
    655  
    656         const char *content_types[] = {SML_ELEMENT_TEXT_VCARD, SML_ELEMENT_TEXT_VCAL, SML_ELEMENT_TEXT_PLAIN}; 
    657         int k = 0; 
    658         for (k = 0; k < datastores; k++) 
    659         { 
    660                 smlDsSessionSendSync(libsyncml_tracker->dssessions[k], 0, _sync_reply, GINT_TO_POINTER(1), &error); 
    661  
    662                 //int i = 0;     
    663                 //for (i = 0; i < num_items; i++) { 
    664                 //      fail_unless(smlDsSessionQueueChange(libsyncml_tracker->dssessions[k], SML_CHANGE_ADD, "uid", "data", 4, content_types[k], _add_reply, GINT_TO_POINTER(1), &error), NULL); 
    665                 //      fail_unless(error == NULL, NULL); 
    666                 //} 
    667  
    668                 smlDsSessionCloseSync(libsyncml_tracker->dssessions[k], &error); 
    669         } 
    670          
    671         fail_unless(smlSessionFlush(libsyncml_tracker->session, TRUE, &error), NULL); 
    672  
    673         libsyncml_state = TEST_LIBSYNCML_STATE_WAIT_FOR_MAP; 
    674  
    675         while(mobile_state == TEST_MOBILE_STATE_WAIT_FOR_SYNC) 
    676         { 
    677                 smlManagerDispatch(libsyncml_manager); 
    678                 usleep(100); 
    679                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    680         } 
    681 } 
    682          
    683 void obex_client_send_end() 
    684 { 
    685         while(mobile_state == TEST_MOBILE_STATE_WAIT_FOR_END) 
    686         { 
    687                 smlManagerDispatch(libsyncml_manager); 
    688                 usleep(100); 
    689                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    690         } 
    691         libsyncml_state = TEST_LIBSYNCML_STATE_FINISHED; 
    692 } 
    693  
    694 void obex_client_disconnect() 
    695 { 
    696         SmlError *error = NULL; 
    697         smlTransportDisconnect(libsyncml_tsp, NULL, &error); 
    698         while (libsyncml_state != TEST_LIBSYNCML_STATE_DISCONNECTED) 
    699         { 
    700                 smlManagerDispatch(libsyncml_manager); 
    701                 usleep(100); 
    702                 fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    703         } 
    704 } 
     81#include "obex_mobile_ds_server.c" 
     82#include "obex_mobile_ds_client.c" 
    70583 
    70684/* ************************************ 
    …… 
    71290{ 
    71391        /* start the server (this is the mobile) */ 
    714         obex_server_connect(); 
     92        obex_mobile_connect(); 
    71593 
    71694        /* start the client (this is libsyncml) */ 
    717         obex_client_connect(); 
    718         obex_client_send_san(); 
    719         obex_client_send_alert(); 
    720         obex_client_send_sync(); 
    721         obex_client_send_end(); 
     95        obex_libsyncml_connect(); 
     96        obex_libsyncml_send_san(); 
     97        obex_libsyncml_send_alert(); 
     98        obex_libsyncml_send_sync(); 
     99        obex_libsyncml_send_end(); 
    722100 
    723         obex_server_disconnect(); 
    724         obex_client_disconnect(); 
     101        obex_mobile_disconnect(); 
     102        obex_libsyncml_disconnect(); 
    725103} 
    726104END_TEST 
    727  
    728 extern const char *mobile_name; 
    729105 
    730106Suite *get_test_suite(void)