TC/testcase/utc_sync_agent_framework_event_omads.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <tet_api.h>
  19
  20 #include <sync_agent.h>
  21
  22 enum {
  23         POSITIVE_TC_IDX = 0x01,
  24         NEGATIVE_TC_IDX,
  25 };
  26
  27 static void startup(void);
  28 static void cleanup(void);
  29
  30 void (*tet_startup) (void) = startup;
  31 void (*tet_cleanup) (void) = cleanup;
  32
  33 #define TEST_FW_CONFIG_OMADS_FILE       "../../../testcase/fw-test-cfg/test_fw_config_omads.xml"
  34
  35 #define OMA_DS_EVENT_NUM 10
  36
  37 #define API_NAME_SYNC_START_UP  "startup"
  38 #define API_NAME_SYNC_CLEAN_UP  "cleanup"
  39
  40 #define API_NAME_SYNC_AGENT_DS_INIT "sync_agent_ds_init"
  41 #define API_NAME_SYNC_AGENT_DS_CREATE_PROFILE_INFO "sync_agent_ds_create_profile_info"
  42 #define API_NAME_SYNC_AGENT_DS_SET_PROFILE_NAME "sync_agent_ds_set_profile_name"
  43 #define API_NAME_SYNC_AGENT_DS_SET_SERVER_INFO "sync_agent_ds_set_server_info"
  44 #define API_NAME_SYNC_AGENT_DS_SET_SYNC_INFO "sync_agent_ds_set_sync_info"
  45 #define API_NAME_SYNC_AGENT_DS_SET_SYNC_SERVICE_INFO "sync_agent_ds_set_sync_service_info"
  46 #define API_NAME_SYNC_AGENT_DS_GET_PROFILE_NAME "sync_agent_ds_get_profile_name"
  47 #define API_NAME_SYNC_AGENT_DS_GET_SERVER_INFO "sync_agent_ds_get_server_info"
  48 #define API_NAME_SYNC_AGENT_DS_GET_SYNC_INFO "sync_agent_ds_get_sync_info"
  49 #define API_NAME_SYNC_AGENT_DS_GET_SYNC_SERVICE_INFO "sync_agent_ds_get_sync_service_info"
  50 #define API_NAME_SYNC_AGENT_DS_GET_LAST_SYNC_INFO "sync_agent_ds_get_last_sync_info"
  51 #define API_NAME_SYNC_AGENT_DS_GET_SYNC_STATISTICS "sync_agent_ds_get_sync_statistics"
  52 #define API_NAME_SYNC_AGENT_DS_ADD_PROFILE "sync_agent_ds_add_profile"
  53 #define API_NAME_SYNC_AGENT_DS_GET_PROFILE "sync_agent_ds_get_profile"
  54 #define API_NAME_SYNC_AGENT_DS_GET_ALL_PROFILE "sync_agent_ds_get_all_profile"
  55 #define API_NAME_SYNC_AGENT_DS_UPDATE_PROFILE "sync_agent_ds_update_profile"
  56 #define API_NAME_SYNC_AGENT_DS_DELETE_PROFILE "sync_agent_ds_delete_profile"
  57 #define API_NAME_SYNC_AGENT_DS_START_SYNC "sync_agent_ds_start_sync"
  58 #define API_NAME_SYNC_AGENT_DS_STOP_SYNC "sync_agent_ds_stop_sync"
  59 #define API_NAME_SYNC_AGENT_DS_FREE_PROFILE_INFO "sync_agent_ds_free_profile_info"
  60 #define API_NAME_SYNC_AGENT_DS_DEINIT "sync_agent_ds_deinit"
  61
  62 #define API_NAME_START_TEST_DS_AGENT "_start_test_ds_agent"
  63
  64 static void utc_sync_agent_framework_sync_agent_sync_agent_ds_init_p(void);
  65 static void utc_sync_agent_framework_sync_agent_ds_create_profile_info_p(void);
  66 static void utc_sync_agent_framework_sync_agent_ds_set_profile_name_p(void);
  67 static void utc_sync_agent_framework_sync_agent_ds_set_server_info_p(void);
  68 static void utc_sync_agent_framework_sync_agent_ds_set_sync_info_p(void);
  69 static void utc_sync_agent_framework_sync_agent_ds_set_sync_service_info_p(void);
  70 static void utc_sync_agent_framework_sync_agent_ds_get_profile_name_p(void);
  71 static void utc_sync_agent_framework_sync_agent_ds_get_server_info_p(void);
  72 static void utc_sync_agent_framework_sync_agent_ds_get_sync_info_p(void);
  73 static void utc_sync_agent_framework_sync_agent_ds_get_sync_service_info_p(void);
  74 static void utc_sync_agent_framework_sync_agent_ds_get_last_sync_info_p(void);
  75 static void utc_sync_agent_framework_sync_agent_ds_get_sync_statistics_p(void);
  76 static void utc_sync_agent_framework_sync_agent_ds_add_profile_p(void);
  77 static void utc_sync_agent_framework_sync_agent_ds_get_profile_p(void);
  78 static void utc_sync_agent_framework_sync_agent_ds_get_all_profile_p(void);
  79 static void utc_sync_agent_framework_sync_agent_ds_update_profile_p(void);
  80 static void utc_sync_agent_framework_sync_agent_ds_delete_profile_p(void);
  81 static void utc_sync_agent_framework_sync_agent_ds_start_sync_p(void);
  82 static void utc_sync_agent_framework_sync_agent_ds_stop_sync_p(void);
  83 //static void utc_sync_agent_framework_sync_agent_ds_free_profile_info_p(void);
  84 static void utc_sync_agent_framework_sync_agent_ds_deinit_p(void);
  85
  86 static void *_start_test_ds_agent(void *arg);
  87 static int (*__get_event_callback(int event_id)) (sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  88 static int ___add_profile_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  89 static int ___update_profile_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  90 static int ___delete_profile_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  91 static int ___start_sync_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  92 static int ___stop_sync_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  93 static int ___get_profile_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  94 static int ___get_sync_category_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  95 static int ___get_sync_statistics_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  96 static int ___get_all_profiles_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  97 static int ___default_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response);
  98
  99 struct tet_testlist tet_testlist[] = {
 100         {utc_sync_agent_framework_sync_agent_sync_agent_ds_init_p, POSITIVE_TC_IDX},
 101         {utc_sync_agent_framework_sync_agent_ds_create_profile_info_p, POSITIVE_TC_IDX},
 102         {utc_sync_agent_framework_sync_agent_ds_set_profile_name_p, POSITIVE_TC_IDX},
 103         {utc_sync_agent_framework_sync_agent_ds_set_server_info_p, POSITIVE_TC_IDX},
 104         {utc_sync_agent_framework_sync_agent_ds_set_sync_info_p, POSITIVE_TC_IDX},
 105         {utc_sync_agent_framework_sync_agent_ds_set_sync_service_info_p, POSITIVE_TC_IDX},
 106         {utc_sync_agent_framework_sync_agent_ds_get_profile_name_p, POSITIVE_TC_IDX},
 107         {utc_sync_agent_framework_sync_agent_ds_get_server_info_p, POSITIVE_TC_IDX},
 108         {utc_sync_agent_framework_sync_agent_ds_get_sync_info_p, POSITIVE_TC_IDX},
 109         {utc_sync_agent_framework_sync_agent_ds_get_sync_service_info_p, POSITIVE_TC_IDX},
 110         {utc_sync_agent_framework_sync_agent_ds_get_last_sync_info_p, POSITIVE_TC_IDX},
 111         {utc_sync_agent_framework_sync_agent_ds_get_sync_statistics_p, POSITIVE_TC_IDX},
 112         {utc_sync_agent_framework_sync_agent_ds_add_profile_p, POSITIVE_TC_IDX},
 113         {utc_sync_agent_framework_sync_agent_ds_get_profile_p, POSITIVE_TC_IDX},
 114         {utc_sync_agent_framework_sync_agent_ds_get_all_profile_p, POSITIVE_TC_IDX},
 115         {utc_sync_agent_framework_sync_agent_ds_update_profile_p, POSITIVE_TC_IDX},
 116         {utc_sync_agent_framework_sync_agent_ds_delete_profile_p, POSITIVE_TC_IDX},
 117         {utc_sync_agent_framework_sync_agent_ds_start_sync_p, POSITIVE_TC_IDX},
 118         {utc_sync_agent_framework_sync_agent_ds_stop_sync_p, POSITIVE_TC_IDX},
 119 //      { utc_sync_agent_framework_sync_agent_ds_free_profile_info_p, POSITIVE_TC_IDX },
 120         {utc_sync_agent_framework_sync_agent_ds_deinit_p, POSITIVE_TC_IDX},
 121         {NULL, 0}
 122 };
 123
 124 static pthread_t test_ds_agent_thread_id;
 125
 126 static void startup(void)
 127 {
 128         /* start of TC */
 129         pthread_create(&test_ds_agent_thread_id, 0, _start_test_ds_agent, 0);
 130
 131         sleep(3);
 132 }
 133
 134 static void cleanup(void)
 135 {
 136         /* clean of TC */
 137         pthread_cancel(test_ds_agent_thread_id);
 138
 139         sync_agent_stop_main_loop(1);
 140 }
 141
 142 static void utc_sync_agent_framework_sync_agent_sync_agent_ds_init_p(void)
 143 {
 144         char *api_name = API_NAME_SYNC_AGENT_DS_INIT;
 145         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 146
 147         ds_err = sync_agent_ds_init();
 148         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 149                 dts_pass(api_name);
 150         } else {
 151                 dts_message(api_name, "sync_agent_ds_init : %d", ds_err);
 152                 dts_fail(api_name);
 153         }
 154 }
 155
 156 static void utc_sync_agent_framework_sync_agent_ds_create_profile_info_p(void)
 157 {
 158         char *api_name = API_NAME_SYNC_AGENT_DS_CREATE_PROFILE_INFO;
 159         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 160
 161         ds_profile_h profile_h = NULL;
 162
 163         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 164         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 165                 dts_pass(api_name);
 166         } else {
 167                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 168                 dts_fail(api_name);
 169         }
 170 }
 171
 172 static void utc_sync_agent_framework_sync_agent_ds_set_profile_name_p(void)
 173 {
 174         char *api_name = API_NAME_SYNC_AGENT_DS_SET_PROFILE_NAME;
 175         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 176
 177         ds_profile_h profile_h = NULL;
 178         char *profile_dir_name = "Sync1";
 179         char *profile_name = "profile name";
 180
 181         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 182         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 183                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 184                 dts_fail(api_name);
 185         }
 186
 187         ds_err = sync_agent_ds_set_profile_name(profile_h, profile_dir_name, profile_name);
 188         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 189                 dts_pass(api_name);
 190         } else {
 191                 dts_message(api_name, "sync_agent_ds_set_profile_name : %d", ds_err);
 192                 dts_fail(api_name);
 193         }
 194 }
 195
 196 static void utc_sync_agent_framework_sync_agent_ds_set_server_info_p(void)
 197 {
 198         char *api_name = API_NAME_SYNC_AGENT_DS_SET_SERVER_INFO;
 199         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 200
 201         ds_profile_h profile_h = NULL;
 202         char *addr = "http://";
 203         char *id = "id";
 204         char *password = "password";
 205
 206         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 207         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 208                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 209                 dts_fail(api_name);
 210         }
 211
 212         ds_err = sync_agent_ds_set_server_info(profile_h, addr, id, password);
 213         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 214                 dts_pass(api_name);
 215         } else {
 216                 dts_message(api_name, "sync_agent_ds_set_server_info : %d", ds_err);
 217                 dts_fail(api_name);
 218         }
 219 }
 220
 221 static void utc_sync_agent_framework_sync_agent_ds_set_sync_info_p(void)
 222 {
 223         char *api_name = API_NAME_SYNC_AGENT_DS_SET_SYNC_INFO;
 224         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 225
 226         ds_profile_h profile_h = NULL;
 227         char *sync_mode = "Periodic";
 228         char *sync_type = "Update both";
 229         char *interval = "1 hour";
 230
 231         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 232         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 233                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 234                 dts_fail(api_name);
 235         }
 236
 237         ds_err = sync_agent_ds_set_sync_info(profile_h, sync_mode, sync_type, interval);
 238         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 239                 dts_pass(api_name);
 240         } else {
 241                 dts_message(api_name, "sync_agent_ds_set_sync_info : %d", ds_err);
 242                 dts_fail(api_name);
 243         }
 244 }
 245
 246 static void utc_sync_agent_framework_sync_agent_ds_set_sync_service_info_p(void)
 247 {
 248         char *api_name = API_NAME_SYNC_AGENT_DS_SET_SYNC_SERVICE_INFO;
 249         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 250
 251         ds_profile_h profile_h = NULL;
 252         sync_agent_ds_service_type_e service_type = SYNC_AGENT_CONTACT;
 253         int enabled = 1;
 254         char *src_uri = "Contacts";
 255         char *tgt_uri = "card";
 256         char *id = "id";
 257         char *password = "password";
 258
 259         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 260         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 261                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 262                 dts_fail(api_name);
 263         }
 264
 265         ds_err = sync_agent_ds_set_sync_service_info(profile_h, service_type, enabled, src_uri, tgt_uri, id, password);
 266         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 267                 dts_pass(api_name);
 268         } else {
 269                 dts_message(api_name, "sync_agent_ds_set_sync_service_info : %d", ds_err);
 270                 dts_fail(api_name);
 271         }
 272 }
 273
 274 static void utc_sync_agent_framework_sync_agent_ds_get_profile_name_p(void)
 275 {
 276         char *api_name = API_NAME_SYNC_AGENT_DS_GET_PROFILE_NAME;
 277         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 278
 279         ds_profile_h profile_h = NULL;
 280         char *profile_dir_name = "Sync1";
 281         char *get_profile_dir_name = NULL;
 282         char *profile_name = NULL;
 283
 284         ds_err = sync_agent_ds_get_profile(profile_dir_name, &profile_h);
 285         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 286                 dts_message(api_name, "sync_agent_ds_get_profile : %d", ds_err);
 287                 dts_fail(api_name);
 288         }
 289
 290         ds_err = sync_agent_ds_get_profile_name(profile_h, &get_profile_dir_name, &profile_name);
 291         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 292                 dts_pass(api_name);
 293         } else {
 294                 dts_message(api_name, "sync_agent_ds_get_profile_name : %d", ds_err);
 295                 dts_fail(api_name);
 296         }
 297 }
 298
 299 static void utc_sync_agent_framework_sync_agent_ds_get_server_info_p(void)
 300 {
 301         char *api_name = API_NAME_SYNC_AGENT_DS_GET_SERVER_INFO;
 302         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 303
 304         ds_profile_h profile_h = NULL;
 305         char *profile_dir_name = "Sync1";
 306         sync_agent_ds_server_info server_info = { NULL };
 307
 308         ds_err = sync_agent_ds_get_profile(profile_dir_name, &profile_h);
 309         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 310                 dts_message(api_name, "sync_agent_ds_get_profile : %d", ds_err);
 311                 dts_fail(api_name);
 312         }
 313
 314         ds_err = sync_agent_ds_get_server_info(profile_h, &server_info);
 315         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 316                 dts_pass(api_name);
 317         } else {
 318                 dts_message(api_name, "sync_agent_ds_get_server_info : %d", ds_err);
 319                 dts_fail(api_name);
 320         }
 321 }
 322
 323 static void utc_sync_agent_framework_sync_agent_ds_get_sync_info_p(void)
 324 {
 325         char *api_name = API_NAME_SYNC_AGENT_DS_GET_SYNC_INFO;
 326         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 327
 328         ds_profile_h profile_h = NULL;
 329         char *profile_dir_name = "Sync1";
 330         sync_agent_ds_sync_info sync_info = { NULL };
 331
 332         ds_err = sync_agent_ds_get_profile(profile_dir_name, &profile_h);
 333         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 334                 dts_message(api_name, "sync_agent_ds_get_profile : %d", ds_err);
 335                 dts_fail(api_name);
 336         }
 337
 338         ds_err = sync_agent_ds_get_sync_info(profile_h, &sync_info);
 339         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 340                 dts_pass(api_name);
 341         } else {
 342                 dts_message(api_name, "sync_agent_ds_get_sync_info : %d", ds_err);
 343                 dts_fail(api_name);
 344         }
 345 }
 346
 347 static void utc_sync_agent_framework_sync_agent_ds_get_sync_service_info_p(void)
 348 {
 349         char *api_name = API_NAME_SYNC_AGENT_DS_GET_SYNC_SERVICE_INFO;
 350         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 351
 352         ds_profile_h profile_h = NULL;
 353         char *profile_dir_name = "Sync1";
 354         GList *service_list = NULL;
 355
 356         ds_err = sync_agent_ds_get_profile(profile_dir_name, &profile_h);
 357         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 358                 dts_message(api_name, "sync_agent_ds_get_profile : %d", ds_err);
 359                 dts_fail(api_name);
 360         }
 361
 362         ds_err = sync_agent_ds_get_sync_service_info(profile_h, &service_list);
 363         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 364                 dts_pass(api_name);
 365         } else {
 366                 dts_message(api_name, "sync_agent_ds_get_sync_service_info : %d", ds_err);
 367                 dts_fail(api_name);
 368         }
 369 }
 370
 371 static void utc_sync_agent_framework_sync_agent_ds_get_last_sync_info_p(void)
 372 {
 373         char *api_name = API_NAME_SYNC_AGENT_DS_GET_LAST_SYNC_INFO;
 374         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 375
 376         ds_profile_h profile_h = NULL;
 377         char *profile_dir_name = "Sync1";
 378         int last_sync_status = 0;
 379         int last_sync_time = 0;
 380
 381         ds_err = sync_agent_ds_get_profile(profile_dir_name, &profile_h);
 382         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 383                 dts_message(api_name, "sync_agent_ds_get_profile : %d", ds_err);
 384                 dts_fail(api_name);
 385         }
 386
 387         ds_err = sync_agent_ds_get_last_sync_info(profile_h, &last_sync_status, &last_sync_time);
 388         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 389                 dts_pass(api_name);
 390         } else {
 391                 dts_message(api_name, "sync_agent_ds_get_last_sync_info : %d", ds_err);
 392                 dts_fail(api_name);
 393         }
 394 }
 395
 396 static void utc_sync_agent_framework_sync_agent_ds_get_sync_statistics_p(void)
 397 {
 398         char *api_name = API_NAME_SYNC_AGENT_DS_GET_SYNC_STATISTICS;
 399         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 400
 401         ds_profile_h profile_h = NULL;
 402         char *profile_dir_name = "Sync1";
 403         GList *statistics_list = NULL;
 404
 405         ds_err = sync_agent_ds_get_profile(profile_dir_name, &profile_h);
 406         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 407                 dts_message(api_name, "sync_agent_ds_get_profile : %d", ds_err);
 408                 dts_fail(api_name);
 409         }
 410
 411         ds_err = sync_agent_ds_get_sync_statistics(profile_h, &statistics_list);
 412         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 413                 dts_pass(api_name);
 414         } else {
 415                 dts_message(api_name, "sync_agent_ds_get_sync_statistics : %d", ds_err);
 416                 dts_fail(api_name);
 417         }
 418 }
 419
 420 static void utc_sync_agent_framework_sync_agent_ds_add_profile_p(void)
 421 {
 422         char *api_name = API_NAME_SYNC_AGENT_DS_ADD_PROFILE;
 423         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 424
 425         ds_profile_h profile_h = NULL;
 426         char *profile_dir_name = "Sync1";
 427         char *profile_name = "profile name";
 428
 429         char *addr = "http://";
 430         char *id = "id";
 431         char *password = "password";
 432
 433         char *sync_mode = "Periodic";
 434         char *sync_type = "Update both";
 435         char *interval = "1 hour";
 436
 437         sync_agent_ds_service_type_e service_type = SYNC_AGENT_CONTACT;
 438         int enabled = 1;
 439         char *src_uri = "Contacts";
 440         char *tgt_uri = "card";
 441
 442         int profile_id = 0;
 443
 444         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 445         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 446                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 447                 dts_fail(api_name);
 448         }
 449
 450         ds_err = sync_agent_ds_set_profile_name(profile_h, profile_dir_name, profile_name);
 451         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 452                 dts_message(api_name, "sync_agent_ds_set_profile_name : %d", ds_err);
 453                 dts_fail(api_name);
 454         }
 455
 456         ds_err = sync_agent_ds_set_server_info(profile_h, addr, id, password);
 457         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 458                 dts_message(api_name, "sync_agent_ds_set_server_info : %d", ds_err);
 459                 dts_fail(api_name);
 460         }
 461
 462         ds_err = sync_agent_ds_set_sync_info(profile_h, sync_mode, sync_type, interval);
 463         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 464                 dts_message(api_name, "sync_agent_ds_set_sync_info : %d", ds_err);
 465                 dts_fail(api_name);
 466         }
 467
 468         ds_err = sync_agent_ds_add_profile(profile_h, &profile_id);
 469         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 470                 dts_pass(api_name);
 471         } else {
 472                 dts_message(api_name, "sync_agent_ds_add_profile : %d", ds_err);
 473                 dts_fail(api_name);
 474         }
 475 }
 476
 477 static void utc_sync_agent_framework_sync_agent_ds_get_profile_p(void)
 478 {
 479         char *api_name = API_NAME_SYNC_AGENT_DS_GET_PROFILE;
 480         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 481
 482         ds_profile_h profile_h = NULL;
 483         char *profile_dir_name = "Sync1";
 484
 485         ds_err = sync_agent_ds_get_profile(profile_dir_name, &profile_h);
 486         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 487                 dts_pass(api_name);
 488         } else {
 489                 dts_message(api_name, "sync_agent_ds_get_profile : %d", ds_err);
 490                 dts_fail(api_name);
 491         }
 492 }
 493
 494 static void utc_sync_agent_framework_sync_agent_ds_get_all_profile_p(void)
 495 {
 496         char *api_name = API_NAME_SYNC_AGENT_DS_GET_ALL_PROFILE;
 497         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 498
 499         GList *profile_list = NULL;
 500
 501         ds_err = sync_agent_ds_get_all_profile(&profile_list);
 502
 503         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 504                 dts_pass(api_name);
 505         } else {
 506                 dts_message(api_name, "sync_agent_ds_get_all_profile : %d", ds_err);
 507                 dts_fail(api_name);
 508         }
 509 }
 510
 511 static void utc_sync_agent_framework_sync_agent_ds_update_profile_p(void)
 512 {
 513         char *api_name = API_NAME_SYNC_AGENT_DS_UPDATE_PROFILE;
 514         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 515
 516         ds_profile_h profile_h = NULL;
 517         char *profile_dir_name = "Sync1";
 518         char *profile_name = "updated profile name";
 519
 520         char *addr = "http://";
 521         char *id = "id";
 522         char *password = "password";
 523
 524         char *sync_mode = "Periodic";
 525         char *sync_type = "Update both";
 526         char *interval = "1 hour";
 527
 528         sync_agent_ds_service_type_e service_type = SYNC_AGENT_CONTACT;
 529         int enabled = 1;
 530         char *src_uri = "Contacts";
 531         char *tgt_uri = "card";
 532
 533         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 534         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 535                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 536                 dts_fail(api_name);
 537         }
 538
 539         ds_err = sync_agent_ds_set_profile_name(profile_h, profile_dir_name, profile_name);
 540         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 541                 dts_message(api_name, "sync_agent_ds_set_profile_name : %d", ds_err);
 542                 dts_fail(api_name);
 543         }
 544
 545         ds_err = sync_agent_ds_set_server_info(profile_h, addr, id, password);
 546         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 547                 dts_message(api_name, "sync_agent_ds_set_server_info : %d", ds_err);
 548                 dts_fail(api_name);
 549         }
 550
 551         ds_err = sync_agent_ds_set_sync_info(profile_h, sync_mode, sync_type, interval);
 552         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 553                 dts_message(api_name, "sync_agent_ds_set_sync_info : %d", ds_err);
 554                 dts_fail(api_name);
 555         }
 556
 557         ds_err = sync_agent_ds_update_profile(profile_h);
 558         sync_agent_ds_free_profile_info(profile_h);
 559
 560         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 561                 dts_pass(api_name);
 562         } else {
 563                 dts_message(api_name, "sync_agent_ds_update_profile : %d", ds_err);
 564                 dts_fail(api_name);
 565         }
 566 }
 567
 568 static void utc_sync_agent_framework_sync_agent_ds_delete_profile_p(void)
 569 {
 570         char *api_name = API_NAME_SYNC_AGENT_DS_DELETE_PROFILE;
 571         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 572
 573         ds_profile_h profile_h = NULL;
 574         char *profileDirName = "Sync1";
 575
 576         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 577         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 578                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 579                 dts_fail(api_name);
 580         }
 581
 582         ds_err = sync_agent_ds_set_profile_name(profile_h, profileDirName, NULL);
 583         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 584                 dts_message(api_name, "sync_agent_ds_set_profile_name : %d", ds_err);
 585                 dts_fail(api_name);
 586         }
 587
 588         ds_err = sync_agent_ds_delete_profile(profile_h);
 589         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 590                 dts_pass(api_name);
 591         } else {
 592                 dts_message(api_name, "sync_agent_ds_delete_profile : %d", ds_err);
 593                 dts_fail(api_name);
 594         }
 595 }
 596
 597 static void utc_sync_agent_framework_sync_agent_ds_start_sync_p(void)
 598 {
 599         char *api_name = API_NAME_SYNC_AGENT_DS_START_SYNC;
 600         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 601
 602         ds_profile_h profile_h = NULL;
 603         char *profileDirName = "Sync1";
 604
 605         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 606         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 607                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 608                 dts_fail(api_name);
 609         }
 610
 611         ds_err = sync_agent_ds_set_profile_name(profile_h, profileDirName, NULL);
 612         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 613                 dts_message(api_name, "sync_agent_ds_set_profile_name : %d", ds_err);
 614                 dts_fail(api_name);
 615         }
 616
 617         ds_err = sync_agent_ds_start_sync(profile_h);
 618         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 619                 dts_pass(api_name);
 620         } else {
 621                 dts_message(api_name, "sync_agent_ds_start_sync : %d", ds_err);
 622                 dts_fail(api_name);
 623         }
 624 }
 625
 626 static void utc_sync_agent_framework_sync_agent_ds_stop_sync_p(void)
 627 {
 628         char *api_name = API_NAME_SYNC_AGENT_DS_STOP_SYNC;
 629         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 630
 631         ds_profile_h profile_h = NULL;
 632         char *profileDirName = "Sync1";
 633
 634         ds_err = sync_agent_ds_create_profile_info(&profile_h);
 635         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 636                 dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 637                 dts_fail(api_name);
 638         }
 639
 640         ds_err = sync_agent_ds_set_profile_name(profile_h, profileDirName, NULL);
 641         if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 642                 dts_message(api_name, "sync_agent_ds_set_profile_name : %d", ds_err);
 643                 dts_fail(api_name);
 644         }
 645
 646         ds_err = sync_agent_ds_stop_sync(profile_h);
 647         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 648                 dts_pass(api_name);
 649         } else {
 650                 dts_message(api_name, "sync_agent_ds_stop_sync : %d", ds_err);
 651                 dts_fail(api_name);
 652         }
 653 }
 654
 655 //static void utc_sync_agent_framework_sync_agent_ds_free_profile_info_p(void)
 656 //{
 657 //      char *api_name = API_NAME_SYNC_AGENT_DS_FREE_PROFILE_INFO;
 658 //      sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 659 //
 660 //      ds_profile_h profile_h = NULL;
 661 //
 662 //      ds_err = sync_agent_ds_create_profile_info(&profile_h);
 663 //      if (ds_err != SYNC_AGENT_DS_SUCCESS) {
 664 //              dts_message(api_name, "sync_agent_ds_create_profile_info : %d", ds_err);
 665 //              dts_fail(api_name);
 666 //      }
 667 //
 668 //      sync_agent_ds_free_profile_info(profile_h);
 669 //}
 670
 671 static void utc_sync_agent_framework_sync_agent_ds_deinit_p(void)
 672 {
 673         char *api_name = API_NAME_SYNC_AGENT_DS_DEINIT;
 674         sync_agent_ds_error_e ds_err = SYNC_AGENT_DS_SUCCESS;
 675
 676         ds_err = sync_agent_ds_deinit();
 677         if (ds_err == SYNC_AGENT_DS_SUCCESS) {
 678                 dts_pass(api_name);
 679         } else {
 680                 dts_message(api_name, "sync_agent_ds_deinit : %d", ds_err);
 681                 dts_fail(api_name);
 682         }
 683 }
 684
 685 static void *_start_test_ds_agent(void *arg)
 686 {
 687         char *api_name = API_NAME_START_TEST_DS_AGENT;
 688         sync_agent_event_error_e event_err = SYNC_AGENT_EVENT_SUCCESS;
 689         sync_agent_init_error_e init_error = sync_agent_init(TEST_FW_CONFIG_OMADS_FILE);
 690         if (init_error != SYNC_AGENT_INIT_SUCCESS) {
 691                 dts_message(api_name, "sync_agent_init : %d", init_error);
 692                 dts_fail(api_name);
 693         }
 694
 695         int event_id = 0;
 696         for (event_id = 1; event_id < OMA_DS_EVENT_NUM; event_id++) {
 697                 event_err = sync_agent_set_event_callback(event_id, __get_event_callback(event_id));
 698                 if (event_err != SYNC_AGENT_EVENT_SUCCESS) {
 699                         dts_message(api_name, "sync_agent_set_event_callback : %d", event_err);
 700                         dts_fail(api_name);
 701                 }
 702         }
 703
 704         sync_agent_run_main_loop(1);
 705 }
 706
 707 static int (*__get_event_callback(int event_id)) (sync_agent_event_data_s * request, sync_agent_event_data_s * response) {
 708         g_print("%s Start \n", __func__);
 709
 710         switch (event_id) {
 711         case 1:
 712                 return ___add_profile_cb;
 713                 break;
 714         case 2:
 715                 return ___update_profile_cb;
 716                 break;
 717         case 3:
 718                 return ___delete_profile_cb;
 719                 break;
 720         case 4:
 721                 return ___start_sync_cb;
 722                 break;
 723         case 5:
 724                 return ___stop_sync_cb;
 725                 break;
 726         case 6:
 727                 return ___get_profile_cb;
 728                 break;
 729         case 7:
 730                 return ___get_sync_category_cb;
 731                 break;
 732         case 8:
 733                 return ___get_sync_statistics_cb;
 734                 break;
 735         case 9:
 736                 return ___get_all_profiles_cb;
 737                 break;
 738         default:
 739                 return ___default_cb;
 740                 break;
 741         }
 742
 743         g_print("%s End \n", __func__);
 744 }
 745
 746 static int ___add_profile_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 747 {
 748         g_print("%s Start \n", __func__);
 749
 750         int event_result = 1;
 751         char *profile_dir_name = NULL;
 752         char *profile_name = NULL;
 753         char *addr = NULL;
 754         char *id = NULL;
 755         char *password = NULL;
 756         char *sync_mode = NULL;
 757         char *sync_type = NULL;
 758         char *interval = NULL;
 759         int category_count = 0;
 760         int account_id = 1;
 761
 762         sync_agent_get_event_data_param(request, &profile_dir_name);
 763         sync_agent_get_event_data_param(request, &profile_name);
 764         sync_agent_get_event_data_param(request, &addr);
 765         sync_agent_get_event_data_param(request, &id);
 766         sync_agent_get_event_data_param(request, &password);
 767         sync_agent_get_event_data_param(request, &sync_mode);
 768         sync_agent_get_event_data_param(request, &sync_type);
 769         sync_agent_get_event_data_param(request, &interval);
 770         sync_agent_get_event_data_param(request, &category_count);
 771
 772         int i = 0;
 773         for (; i < category_count; i++) {
 774                 sync_agent_ds_service_info *category = NULL;
 775                 sync_agent_get_event_data_param(request, &(category->service_type));
 776                 sync_agent_get_event_data_param(request, &(category->enabled));
 777                 sync_agent_get_event_data_param(request, &(category->src_uri));
 778                 sync_agent_get_event_data_param(request, &(category->tgt_uri));
 779                 sync_agent_get_event_data_param(request, &(category->id));
 780                 sync_agent_get_event_data_param(request, &(category->password));
 781         }
 782
 783         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 784         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &account_id);
 785
 786         g_print("%s End \n", __func__);
 787
 788         return 1;
 789 }
 790
 791 static int ___update_profile_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 792 {
 793         g_print("%s Start \n", __func__);
 794
 795         int event_result = 1;
 796         char *profile_dir_name = NULL;
 797         char *profile_name = NULL;
 798         char *addr = NULL;
 799         char *id = NULL;
 800         char *password = NULL;
 801         char *sync_mode = NULL;
 802         char *sync_type = NULL;
 803         char *interval = NULL;
 804         int category_count = 0;
 805
 806         sync_agent_get_event_data_param(request, &profile_dir_name);
 807         sync_agent_get_event_data_param(request, &profile_name);
 808         sync_agent_get_event_data_param(request, &addr);
 809         sync_agent_get_event_data_param(request, &id);
 810         sync_agent_get_event_data_param(request, &password);
 811         sync_agent_get_event_data_param(request, &sync_mode);
 812         sync_agent_get_event_data_param(request, &sync_type);
 813         sync_agent_get_event_data_param(request, &interval);
 814         sync_agent_get_event_data_param(request, &category_count);
 815
 816         int i = 0;
 817         for (; i < category_count; i++) {
 818                 sync_agent_ds_service_info *category = NULL;
 819                 sync_agent_get_event_data_param(request, &(category->service_type));
 820                 sync_agent_get_event_data_param(request, &(category->enabled));
 821                 sync_agent_get_event_data_param(request, &(category->src_uri));
 822                 sync_agent_get_event_data_param(request, &(category->tgt_uri));
 823                 sync_agent_get_event_data_param(request, &(category->id));
 824                 sync_agent_get_event_data_param(request, &(category->password));
 825         }
 826
 827         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 828
 829         g_print("%s End \n", __func__);
 830
 831         return 1;
 832 }
 833
 834 static int ___delete_profile_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 835 {
 836         g_print("%s Start \n", __func__);
 837
 838         int event_result = 1;
 839         int count = 0;
 840         sync_agent_get_event_data_param(request, &count);
 841
 842         int i;
 843         char *profile = NULL;
 844         for (i = 0; i < count; i++) {
 845                 sync_agent_get_event_data_param(request, &profile);
 846         }
 847
 848         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 849
 850         g_print("%s End \n", __func__);
 851
 852         return 1;
 853 }
 854
 855 static int ___start_sync_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 856 {
 857         g_print("%s Start \n", __func__);
 858
 859         int event_result = 1;
 860         char *profile = NULL;
 861
 862         sync_agent_get_event_data_param(request, &profile);
 863
 864         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 865
 866         if (profile != NULL)
 867                 free(profile);
 868
 869         g_print("%s End \n", __func__);
 870
 871         return 1;
 872 }
 873
 874 static int ___stop_sync_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 875 {
 876         g_print("%s Start \n", __func__);
 877
 878         int event_result = 1;
 879         char *profile = NULL;
 880
 881         sync_agent_get_event_data_param(request, &profile);
 882
 883         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 884
 885         if (profile != NULL)
 886                 free(profile);
 887
 888         g_print("%s End \n", __func__);
 889
 890         return 1;
 891 }
 892
 893 static int ___get_profile_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 894 {
 895         g_print("%s Start \n", __func__);
 896
 897         int event_result = 1;
 898         char *profile = NULL;
 899         char *profile_name = strdup("profile name");
 900         char *addr = strdup("addr");
 901         char *id = strdup("id");
 902         char *password = strdup("password");
 903         char *sync_mode = strdup("sync_mode");
 904         char *sync_type = strdup("sync_type");
 905         char *interval = strdup("interval");
 906         int last_session_status = 0;
 907         int last_session_time = 0;
 908
 909         sync_agent_get_event_data_param(request, &profile);
 910
 911         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 912         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)profile_name);
 913         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)addr);
 914         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)id);
 915         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)password);
 916         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)sync_mode);
 917         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)sync_type);
 918         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)interval);
 919         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &last_session_status);
 920         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &last_session_time);
 921
 922         if (profile != NULL)
 923                 free(profile);
 924
 925         g_print("%s End \n", __func__);
 926
 927         return 1;
 928 }
 929
 930 static int ___get_sync_category_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 931 {
 932         g_print("%s Start \n", __func__);
 933
 934         int event_result = 1;
 935         char *profile = NULL;
 936         int content_type = 0;
 937         int enabled = 0;
 938         char *srcURI = strdup("srcURI");
 939         char *tgtURI = strdup("tgtURI");
 940         char *id = strdup("id");
 941         char *password = strdup("password");
 942
 943         sync_agent_get_event_data_param(request, &profile);
 944         sync_agent_get_event_data_param(request, &content_type);
 945
 946         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 947         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &enabled);
 948         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)srcURI);
 949         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)tgtURI);
 950         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)id);
 951         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)password);
 952
 953         if (profile != NULL)
 954                 free(profile);
 955
 956         g_print("%s End \n", __func__);
 957
 958         return 1;
 959 }
 960
 961 static int ___get_sync_statistics_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
 962 {
 963         g_print("%s Start \n", __func__);
 964
 965         int event_result = 1;
 966         char *profile = NULL;
 967         int content_type = 0;
 968         char *dbSynced = strdup("NO");
 969         int last_session_time = 0;
 970         int server2Client_Total = 0;
 971         int server2Client_NrOfAdd = 0;
 972         int server2Client_NrOfDelete = 0;
 973         int server2Client_NrOfReplace = 0;
 974         int client2Server_Total = 0;
 975         int client2Server_NrOfAdd = 0;
 976         int client2Server_NrOrDelete = 0;
 977         int client2Server_NrOfReplace = 0;
 978
 979         sync_agent_get_event_data_param(request, &profile);
 980         sync_agent_get_event_data_param(request, &content_type);
 981
 982         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
 983         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)dbSynced);
 984         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &last_session_time);
 985         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &server2Client_Total);
 986         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &server2Client_NrOfAdd);
 987         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &server2Client_NrOfDelete);
 988         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &server2Client_NrOfReplace);
 989         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &client2Server_Total);
 990         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &client2Server_NrOfAdd);
 991         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &client2Server_NrOrDelete);
 992         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &client2Server_NrOfReplace);
 993
 994         if (profile != NULL)
 995                 free(profile);
 996
 997         g_print("%s End \n", __func__);
 998
 999         return 1;
1000 }
1001
1002 static int ___get_all_profiles_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
1003 {
1004         g_print("%s Start \n", __func__);
1005
1006         int event_result = 1;
1007         int profile_count = 1;
1008         int category_count = 1;
1009         sync_agent_ds_service_info *category_info = NULL;
1010
1011         char *profile_dir_name = strdup("profile_dir_name");
1012         char *profile_name = strdup("profile_name");
1013         char *addr = strdup("addr");
1014         char *id = strdup("id");
1015         char *password = strdup("password");
1016         char *sync_mode = strdup("sync_mode");
1017         char *sync_type = strdup("sync_type");
1018         char *interval = strdup("interval");
1019         int last_sync_status = 0;
1020         int last_sync_time = 1;
1021         int service_type = 1;
1022         int enabled = 1;
1023         char *src_uri = strdup("src_uri");
1024         char *tgt_uri = strdup("tgt_uri");
1025
1026         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &event_result);
1027         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &profile_count);
1028         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)profile_dir_name);
1029         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)profile_name);
1030         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)addr);
1031         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)id);
1032         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)password);
1033         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)sync_mode);
1034         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)sync_type);
1035         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)interval);
1036         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &last_sync_status);
1037         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &last_sync_time);
1038
1039         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &category_count);
1040
1041         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &service_type);
1042         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_INTEGER, &enabled);
1043         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)src_uri);
1044         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)tgt_uri);
1045         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)id);
1046         sync_agent_append_event_data_param(response, SYNC_AGENT_EVENT_PARAM_TYPE_STRING, (void *)password);
1047
1048         g_print("%s End \n", __func__);
1049
1050         return 1;
1051 }
1052
1053 static int ___default_cb(sync_agent_event_data_s * request, sync_agent_event_data_s * response)
1054 {
1055         g_print("%s Start \n", __func__);
1056
1057         g_print("%s End \n", __func__);
1058
1059         return 1;
1060 }