Changeset 500

Show
Ignore:
Timestamp:
07/16/08 15:29:47 (4 months ago)
Author:
bellmich
Message:

- added serverside OMA DS 1.2 SAN support
- activated san_12 test of check_sync
- better error detection for all check_sync tests

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/libsyncml/sml_manager.c

    r492 r500  
    217217                        if (!parser) 
    218218                                goto session_error; 
     219                        /* add manager to parser for OMA DS 1.2 SAN handling */ 
     220                        smlParserSetManager(parser, manager); 
    219221                         
    220222                        /* start to parse the data */ 

  • trunk/libsyncml/sml_notification.c

    r492 r500  
    194194        if (!san) 
    195195                goto error; 
     196        san->type = SML_MIMETYPE_SAN; 
    196197 
    197198        /* Version */ 
    …… 
    313314} 
    314315 
    315 static SmlBool _smlNotificationAssemble11(SmlNotification *san, char **data, unsigned int *size, SmlProtocolVersion version, SmlError **error) 
     316SmlBool smlNotificationAssemble11(SmlNotification *san, char **data, unsigned int *size, SmlProtocolVersion version, SmlError **error) 
    316317{ 
    317318        smlTrace(TRACE_ENTRY, "%s(%p, %p, %p, %i, %p)", __func__, san, data, size, version, error); 
    …… 
    514515                        return _smlNotificationAssemble12(san, data, size, error); 
    515516                case SML_SAN_VERSION_10: 
    516                         return _smlNotificationAssemble11(san, data, size, SML_VERSION_10, error); 
     517                        return smlNotificationAssemble11(san, data, size, SML_VERSION_10, error); 
    517518                case SML_SAN_VERSION_11: 
    518                         return _smlNotificationAssemble11(san, data, size, SML_VERSION_11, error); 
     519                        return smlNotificationAssemble11(san, data, size, SML_VERSION_11, error); 
    519520                case SML_SAN_VERSION_UNKNOWN: 
    520521                        smlErrorSet(error, SML_ERROR_GENERIC, "Unknown SAN version."); 

  • trunk/libsyncml/sml_notification_internals.h

    r486 r500  
    4545}; 
    4646 
     47SmlBool smlNotificationAssemble11( 
     48        SmlNotification *san, 
     49        char **data, 
     50        unsigned int *size, 
     51        SmlProtocolVersion version, 
     52        SmlError **error); 
     53 
    4754#endif //_SML_NOTIFICATION_INTERNALS_H_ 

  • trunk/libsyncml/sml_parse.c

    r474 r500  
    2525#include "sml_command_internals.h" 
    2626#include "sml_elements_internals.h" 
     27#include "sml_notification_internals.h" 
    2728 
    2829#include "parser/sml_xml_assm.h" 
    …… 
    5859        switch (type) { 
    5960                case SML_MIMETYPE_XML: 
     61                        if (!(parser->parser_userdata = smlXmlParserNew(&(parser->functions), error))) 
     62                                goto error_free_parser; 
     63                        break; 
     64                case SML_MIMETYPE_SAN: 
     65                        /* SANs will be converted to normal SyncML 1.1 notifications */ 
    6066                        if (!(parser->parser_userdata = smlXmlParserNew(&(parser->functions), error))) 
    6167                                goto error_free_parser; 
    …… 
    8591} 
    8692 
     93void smlParserSetManager(SmlParser *parser, SmlManager *manager) 
     94{ 
     95        smlAssert(parser); 
     96        smlAssert(manager); 
     97        parser->manager = manager; 
     98} 
     99 
    87100/** @brief Frees a parser 
    88101 *  
    …… 
    121134        smlAssert(size); 
    122135        smlAssert(parser->functions.start); 
    123                  
     136        smlAssertMsg(parser->type != SML_MIMETYPE_SAN || parser->manager, 
     137                SML_ASSERT_MSG_SAN_PARSE_REQUIRES_MANAGER); 
     138         
    124139        if (parser->limit && size > parser->limit) { 
    125140                smlErrorSet(error, SML_ERROR_GENERIC, "Input data too large"); 
    126141                goto error; 
    127142        } 
    128          
    129         if (!parser->functions.start(parser->parser_userdata, data, size, error)) 
    130                 goto error; 
     143 
     144        if (parser->type == SML_MIMETYPE_SAN) { 
     145                /* convert OMA DS 1.2 SAN into an SyncML 1.1 notification */ 
     146                smlTrace(TRACE_INTERNAL, "%s - detected an OMA DS 1.2 SAN", __func__); 
     147 
     148                /* parse the SAN */ 
     149                SmlNotification *san = smlNotificationParse(data, size, error); 
     150                if (!san) 
     151                        goto error; 
     152 
     153                /* fix 1.2 SAN for use with SyncML 1.1 */ 
     154                smlNotificationSetManager(san, parser->manager); 
     155                san->type = SML_MIMETYPE_XML; 
     156                san->sessionType = SML_SESSION_TYPE_CLIENT; 
     157                san->target = smlLocationNew("/", NULL, error); 
     158                if (!san->target) 
     159                        goto error; 
     160 
     161                /* assemble a SyncML 1.1 notification */ 
     162                char *xmlData = NULL; 
     163                unsigned int xmlSize = 0; 
     164                if (!smlNotificationAssemble11(san, &xmlData, &xmlSize, SML_VERSION_12, error)) 
     165                        goto error; 
     166                smlTrace(TRACE_INTERNAL, 
     167                        "%s - converted OMA DS 1.2 SAN to SyncML 1.1 server alerted sync - %s", 
     168                        __func__, xmlData); 
     169 
     170                /* run the parser on the converted SAN */ 
     171                if (!parser->functions.start(parser->parser_userdata, xmlData, xmlSize, error)) { 
     172                        smlSafeCFree(&xmlData); 
     173                        goto error; 
     174                } 
     175                smlSafeCFree(&xmlData);  
     176        } else { 
     177                /* run the parser directly on the data */ 
     178                if (!parser->functions.start(parser->parser_userdata, data, size, error)) 
     179                        goto error; 
     180        } 
    131181         
    132182        smlTrace(TRACE_EXIT, "%s", __func__); 

  • trunk/libsyncml/sml_parse.h

    r474 r500  
    133133int smlAssemblerGetRequestedMaxObjSize(SmlAssembler *assm) LIBSYNCML_DEPRECATED; 
    134134 
     135/* If you want to parse OMA DS 1.2 SANs then the manager is required. */ 
     136void smlParserSetManager(SmlParser *parser, SmlManager *manager); 
     137 
    135138#endif //_SML_PARSE_H_ 

  • trunk/libsyncml/sml_parse_internals.h

    r474 r500  
    2727        SmlMimeType type; 
    2828        unsigned int limit; 
     29        SmlManager *manager; 
    2930}; 
    3031 

  • trunk/libsyncml/syncml_internals.h

    r491 r500  
    6161#define SML_ASSERT_MSG_ERROR_MUST_BE_AVAILABLE "If this function is used then there must be an error." 
    6262#define SML_ASSERT_MSG_ERROR_MUST_BE_FILLED "If this function is used then the error message must be present." 
     63#define SML_ASSERT_MSG_SAN_PARSE_REQUIRES_MANAGER "If an OMA DS 1.2 SAN must be parsed then the manager must be present." 
    6364 
    6465#endif 

  • trunk/libsyncml/transports/obex_client.c

    r493 r500  
    11121112     
    11131113        /* Lets see if it was successfull */ 
     1114        smlTrace(TRACE_INTERNAL, "%s: Wait for the answer ...", __func__); 
    11141115        while (env->busy) { 
    11151116                if (OBEX_HandleInput(env->obexhandle, 20) < 0) { 

  • trunk/tests/check_sync.c

    r496 r500  
    383383                smlManagerDispatch(clientmanager); 
    384384                usleep(100); 
    385                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     385                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    386386        } 
    387387         
    …… 
    399399                smlManagerDispatch(clientmanager); 
    400400                usleep(100); 
    401                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     401                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    402402        } 
    403403         
    …… 
    559559                smlManagerDispatch(clientmanager); 
    560560                usleep(100); 
    561                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     561                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    562562        } 
    563563         
    …… 
    589589                smlManagerDispatch(clientmanager); 
    590590                usleep(100); 
    591                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     591                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    592592        } 
    593593 
    …… 
    632632                smlManagerDispatch(clientmanager); 
    633633                usleep(100); 
    634                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     634                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    635635        } 
    636636         
    …… 
    645645                smlManagerDispatch(clientmanager); 
    646646                usleep(100); 
    647                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     647                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    648648        } 
    649649         
    …… 
    827827                smlManagerDispatch(clientmanager); 
    828828                usleep(100); 
    829                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     829                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    830830        } 
    831831         
    …… 
    857857                smlManagerDispatch(clientmanager); 
    858858                usleep(100); 
    859                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     859                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    860860        } 
    861861         
    …… 
    900900                smlManagerDispatch(clientmanager); 
    901901                usleep(100); 
    902                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     902                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    903903        } 
    904904         
    …… 
    941941                smlManagerDispatch(clientmanager); 
    942942                usleep(100); 
    943                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     943                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    944944        } 
    945945 
    …… 
    969969                smlManagerDispatch(clientmanager); 
    970970                usleep(100); 
    971                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     971                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    972972        } 
    973973         
    …… 
    982982                smlManagerDispatch(clientmanager); 
    983983                usleep(100); 
    984                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     984                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    985985        } 
    986986         
    …… 
    12351235                smlManagerDispatch(clientmanager); 
    12361236                usleep(100); 
    1237                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1237                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    12381238        } 
    12391239         
    …… 
    12531253                smlDsSessionDispatch(servertracker->dssessions[2]); 
    12541254                usleep(100); 
    1255                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1255                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    12561256        } 
    12571257         
    …… 
    12891289                smlManagerDispatch(clientmanager); 
    12901290                usleep(100); 
    1291                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1291                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    12921292        } 
    12931293         
    …… 
    13421342                smlManagerDispatch(clientmanager); 
    13431343                usleep(100); 
    1344                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1344                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    13451345        } 
    13461346         
    …… 
    13831383                smlManagerDispatch(clientmanager); 
    13841384                usleep(100); 
    1385                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1385                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    13861386        } 
    13871387 
    …… 
    14111411                smlManagerDispatch(clientmanager); 
    14121412                usleep(100); 
    1413                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1413                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    14141414        } 
    14151415         
    …… 
    14311431                smlManagerDispatch(clientmanager); 
    14321432                usleep(100); 
    1433                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1433                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    14341434        } 
    14351435         
    …… 
    16361636                smlManagerDispatch(clientmanager); 
    16371637                usleep(100); 
    1638                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1638                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    16391639        } 
    16401640         
    …… 
    16661666                smlManagerDispatch(clientmanager); 
    16671667                usleep(100); 
    1668                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1668                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    16691669        } 
    16701670         
    …… 
    17091709                smlManagerDispatch(clientmanager); 
    17101710                usleep(100); 
    1711                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1711                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    17121712        } 
    17131713         
    …… 
    17221722                smlManagerDispatch(clientmanager); 
    17231723                usleep(100); 
    1724                 fail_unless(session_errors == 0, smlErrorPrint(&eventError)); 
     1724                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    17251725        } 
    17261726         
    …… 
    18081808         
    18091809        SmlError *error = NULL; 
    1810         SmlTransport *server = smlTransportNew(SML_TRANSPORT_OBEX_SERVER, &error); 
    1811         SmlTransport *client = smlTransportNew(SML_TRANSPORT_OBEX_CLIENT, &error); 
    1812          
    1813         fail_unless(smlTransportSetConfigOption(client, "URL", "127.0.0.1", &error), NULL); 
     1810        SmlTransport *server = smlTransportNew(SML_TRANSPORT_OBEX_CLIENT, &error); 
     1811        SmlTransport *client = smlTransportNew(SML_TRANSPORT_OBEX_SERVER, &error); 
     1812         
    18141813        fail_unless(smlTransportSetConfigOption(client, "PORT", "10110", &error), NULL); 
    18151814        fail_unless(smlTransportSetConnectionType(client, SML_TRANSPORT_CONNECTION_TYPE_NET, &error), NULL); 
    18161815 
     1816        fail_unless(smlTransportSetConfigOption(server, "URL", "127.0.0.1", &error), NULL); 
    18171817        fail_unless(smlTransportSetConfigOption(server, "PORT", "10110", &error), NULL); 
    18181818        fail_unless(smlTransportSetConnectionType(server, SML_TRANSPORT_CONNECTION_TYPE_NET, &error), NULL); 
    18191819         
    18201820        managerTracker *clienttracker = g_malloc0(sizeof(managerTracker)); 
    1821         SmlManager *clientmanager = clienttracker->manager = smlManagerNew(server, &error); 
     1821        SmlManager *clientmanager = clienttracker->manager = smlManagerNew(client, &error); 
    18221822        smlManagerSetEventCallback(clienttracker->manager, _manager_event, clienttracker); 
    18231823        managerTracker *servertracker = g_malloc0(sizeof(managerTracker)); 
    1824         SmlManager *servermanager = servertracker->manager = smlManagerNew(client, &error); 
     1824        SmlManager *servermanager = servertracker->manager = smlManagerNew(server, &error); 
    18251825        smlManagerSetEventCallback(servertracker->manager, _manager_event, servertracker); 
    1826          
     1826        smlManagerSetLocalMaxMsgSize(servertracker->manager, TEST_DEFAULT_MAX_MSG_SIZE); 
     1827        smlManagerSetLocalMaxObjSize(servertracker->manager, TEST_DEFAULT_MAX_OBJ_SIZE); 
     1828         
     1829        fail_unless(smlManagerStart(clientmanager, &error), NULL); 
     1830        fail_unless(error == NULL, NULL); 
     1831        fail_unless(smlManagerStart(servermanager, &error), NULL); 
     1832        fail_unless(error == NULL, NULL); 
     1833 
    18271834        fail_unless(smlTransportInitialize(client, &error), NULL); 
    18281835        fail_unless(smlTransportInitialize(server, &error), NULL); 
    1829  
    1830         fail_unless(smlManagerStart(clientmanager, &error), NULL); 
    1831         fail_unless(error == NULL, NULL); 
    1832         fail_unless(smlManagerStart(servermanager, &error), NULL); 
    1833         fail_unless(error == NULL, NULL); 
    18341836 
    18351837        SmlLocation *loc1 = smlLocationNew("test1", NULL, &error); 
    …… 
    18791881        smlAuthRegister(auth2, servermanager, &error); 
    18801882         
    1881         fail_unless(smlTransportConnect(client, &error), NULL); 
     1883        fail_unless(smlTransportConnect(server, &error), NULL); 
    18821884        fail_unless(error == NULL, NULL); 
    18831885         
    …… 
    18851887        fail_unless(san != NULL, NULL); 
    18861888        fail_unless(error == NULL, NULL); 
     1889        smlNotificationSetManager(san, servermanager); 
    18871890         
    18881891        fail_unless(smlDsServerAddSan(servertracker->ds[0], san, &error), NULL); 
    …… 
    18931896        fail_unless(error == NULL, NULL); 
    18941897 
    1895         /* FIXME: Clients never send SANs. They only receive SANs. */ 
    1896         fail_unless(smlNotificationSend(san, client, &error), NULL); 
    1897         fail_unless(error == NULL, NULL); 
     1898        fail_unless(smlNotificationSend(san, server, &error), smlErrorPrint(&error)); 
     1899        fail_unless(error == NULL, smlErrorPrint(&error)); 
    18981900         
    18991901        while (sans_received < 3 || num_sessions < 1) { 
    …… 
    19011903                smlManagerDispatch(clientmanager); 
    19021904                usleep(100); 
     1905                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    19031906        } 
    19041907         
    …… 
    19161919                smlManagerDispatch(clientmanager); 
    19171920                usleep(100); 
     1921                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    19181922        } 
    19191923         
    …… 
    19451949                smlManagerDispatch(clientmanager); 
    19461950                usleep(100); 
    1947         } 
    1948          
    1949         smlDsSessionSendSync(clienttracker->dssessions[0], num_items, _sync_reply, GINT_TO_POINTER(1), &error); 
    1950         smlDsSessionSendSync(clienttracker->dssessions[1], num_items, _sync_reply, GINT_TO_POINTER(1), &error); 
    1951         smlDsSessionSendSync(clienttracker->dssessions[2], num_items, _sync_reply, GINT_TO_POINTER(1), &error); 
    1952          
    1953         int i = 0; 
    1954         for (i = 0; i < num_items; i++) { 
    1955                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[0], SML_CHANGE_ADD, "uid", "data", 4, SML_ELEMENT_TEXT_VCARD, _add_reply, GINT_TO_POINTER(2), &error), NULL); 
    1956                 fail_unless(error == NULL, NULL); 
    1957                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[0], SML_CHANGE_REPLACE, "uid", "newdata", 7, SML_ELEMENT_TEXT_VCARD, _modify_reply, GINT_TO_POINTER(1), &error), NULL); 
    1958                 fail_unless(error == NULL, NULL); 
    1959                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[0], SML_CHANGE_DELETE, "uid", NULL, 0, SML_ELEMENT_TEXT_VCARD, _delete_reply, GINT_TO_POINTER(1), &error), NULL); 
    1960                 fail_unless(error == NULL, NULL); 
    1961                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[1], SML_CHANGE_ADD, "uid", "data", 4, SML_ELEMENT_TEXT_VCAL, _add_reply, GINT_TO_POINTER(2), &error), NULL); 
    1962                 fail_unless(error == NULL, NULL); 
    1963                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[1], SML_CHANGE_REPLACE, "uid", "newdata", 7, SML_ELEMENT_TEXT_VCAL, _modify_reply, GINT_TO_POINTER(1), &error), NULL); 
    1964                 fail_unless(error == NULL, NULL); 
    1965                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[1], SML_CHANGE_DELETE, "uid", NULL, 0, SML_ELEMENT_TEXT_VCAL, _delete_reply, GINT_TO_POINTER(1), &error), NULL); 
    1966                 fail_unless(error == NULL, NULL); 
    1967                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[2], SML_CHANGE_ADD, "uid", "data", 4, SML_ELEMENT_TEXT_PLAIN, _add_reply, GINT_TO_POINTER(2), &error), NULL); 
    1968                 fail_unless(error == NULL, NULL); 
    1969                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[2], SML_CHANGE_REPLACE, "uid", "newdata", 7, SML_ELEMENT_TEXT_PLAIN, _modify_reply, GINT_TO_POINTER(1), &error), NULL); 
    1970                 fail_unless(error == NULL, NULL); 
    1971                 fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[2], SML_CHANGE_DELETE, "uid", NULL, 0, SML_ELEMENT_TEXT_PLAIN, _delete_reply, GINT_TO_POINTER(1), &error), NULL); 
    1972                 fail_unless(error == NULL, NULL); 
    1973         } 
    1974          
    1975         smlDsSessionCloseSync(clienttracker->dssessions[0], &error); 
    1976         smlDsSessionCloseSync(clienttracker->dssessions[1], &error); 
    1977         smlDsSessionCloseSync(clienttracker->dssessions[2], &error); 
     1951                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
     1952        } 
     1953         
     1954        const char *content_types[] = {SML_ELEMENT_TEXT_VCARD, SML_ELEMENT_TEXT_VCAL, SML_ELEMENT_TEXT_PLAIN}; 
     1955        int k = 0; 
     1956        for (k = 0; k < 3; k++) 
     1957        { 
     1958                smlDsSessionSendSync(clienttracker->dssessions[k], num_changes, _sync_reply, GINT_TO_POINTER(1), &error); 
     1959         
     1960                int i = 0; 
     1961                for (i = 0; i < num_items; i++) { 
     1962                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_ADD, "uid", "data", 4, content_types[k], _add_reply, GINT_TO_POINTER(2), &error), NULL); 
     1963                        fail_unless(error == NULL, NULL); 
     1964                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_REPLACE, "uid", "newdata", 7, content_types[k], _modify_reply, GINT_TO_POINTER(1), &error), NULL); 
     1965                        fail_unless(error == NULL, NULL); 
     1966                        fail_unless(smlDsSessionQueueChange(clienttracker->dssessions[k], SML_CHANGE_DELETE, "uid", NULL, 0, content_types[k], _delete_reply, GINT_TO_POINTER(1), &error), NULL); 
     1967                        fail_unless(error == NULL, NULL); 
     1968                } 
     1969 
     1970                smlDsSessionCloseSync(clienttracker->dssessions[k], &error); 
     1971        } 
    19781972         
    19791973        fail_unless(smlSessionFlush(clienttracker->session, TRUE, &error), NULL); 
    …… 
    19981992                smlManagerDispatch(clientmanager); 
    19991993                usleep(100); 
     1994                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    20001995        } 
    20011996         
    …… 
    20102005                smlManagerDispatch(clientmanager); 
    20112006                usleep(100); 
     2007                fail_unless(eventError == NULL, smlErrorPrint(&eventError)); 
    20122008        } 
    20132009         
    …… 
    20752071        create_case(s, "sync_multi_conf_from_devinf", sync_multi_conf_from_devinf); 
    20762072        create_case(s, "sync_send_san", sync_send_san); 
    2077         /* OMA DS 1.2 SAN support is not fully implemented until now. */ 
    2078         // create_case(s, "sync_send_san12", sync_send_san12); 
     2073        create_case(s, "sync_send_san12", sync_send_san12); 
    20792074         
    20802075        return s;