TC/testcase/utc_sync_agent_framework_device_manager.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_FILE     "../../../testcase/fw-test-cfg/test_fw_config.xml"
  34
  35 #define API_NAME_SYNC_START_UP  "startup"
  36
  37 ///////////////////////////////////mo_accessor.h//////////////////////////////////////////
  38 #define API_NAME_SYNC_AGENT_CREATE_MO_ITEM      "sync_agent_create_mo_item"
  39 #define API_NAME_SYNC_AGENT_ADD_MO_ITEM         "sync_agent_add_mo_item"
  40 #define API_NAME_SYNC_AGENT_UPDATE_MO_ITEM      "sync_agent_update_mo_item"
  41 #define API_NAME_SYNC_AGENT_DELETE_MO_ITEM      "sync_agent_delete_mo_item"
  42 #define API_NAME_SYNC_AGENT_DELETE_MO_TREE_ITEM "sync_agent_delete_mo_tree_item"
  43 #define API_NAME_SYNC_AGENT_GET_MO_ITEM "sync_agent_get_mo_item"
  44 #define API_NAME_SYNC_AGENT_GET_MO_ITEMS        "sync_agent_get_mo_items"
  45 #define API_NAME_SYNC_AGENT_QUERY_MO_ITEM "sync_agent_query_mo_item"
  46 #define API_NAME_SYNC_AGENT_FREE_MO_ITEM        "sync_agent_free_mo_item"
  47 #define API_NAME_SYNC_AGENT_CREATE_MO_ACC_ITEM  "sync_agent_create_mo_acc_item"
  48 #define API_NAME_SYNC_AGENT_UPDATE_MO_ACC_ITEM  "sync_agent_update_mo_acc_item"
  49 #define API_NAME_SYNC_AGENT_GET_MO_ACC_ITEM     "sync_agent_get_mo_acc_item"
  50 #define API_NAME_SYNC_AGENT_FREE_MO_ACC_ITEM    "sync_agent_free_mo_acc_item"
  51 #define API_NAME_SYNC_AGENT_INITIALIZE                          "sync_agent_initialize"
  52 #define API_NAME_SYNC_AGENT_OPEN                                                "sync_agent_open"
  53 #define API_NAME_SYNC_AGENT_CLOSE                                               "sync_agent_close"
  54 #define API_NAME_SYNC_AGENT_BEGIN_TRANSACTION_MO        "sync_agent_begin_transaction_mo"
  55 #define API_NAME_SYNC_AGENT_END_TRANSACTION_MO          "sync_agent_end_transaction_mo"
  56 #define API_NAME_SYNC_AGENT_CONSTRUCT_MO_TABLE          "sync_agent_construct_mo_table"
  57 #define API_NAME_SYNC_AGENT_UPTODATE_MO_TABLE           "sync_agent_uptodate_mo_table"
  58 #define API_NAME_SYNC_AGENT_DELETE_ALL_MO_TABLE                 "sync_agent_delete_all_mo_table"
  59 #define API_NAME_SYNC_AGENT_GET_SERVERINFO                      "sync_agent_get_serverinfo"
  60 #define API_NAME_SYNC_AGENT_FREE_SERVERINFO                     "sync_agent_free_serverinfo"
  61 #define API_NAME_SYNC_AGENT_GET_SERVERID                                "sync_agent_get_serverid"
  62 #define API_NAME_SYNC_AGENT_GET_ROOT_PATH                               "sync_agent_get_root_path"
  63 #define API_NAME_SYNC_AGENT_GET_SERVER_TYPE                     "sync_agent_get_server_type"
  64 #define API_NAME_SYNC_AGENT_IS_EXIST_MO                         "sync_agent_is_exist_mo"
  65 #define API_NAME_SYNC_AGENT_GET_MO_TYPE                         "sync_agent_get_mo_type"
  66 #define API_NAME_SYNC_AGENT_CHECK_ACL_VALUE                             "sync_agent_check_acl_value"
  67 #define API_NAME_SYNC_AGENT_DESCENDANT_MO_TREE                  "sync_agent_descendant_mo_tree"
  68 #define API_NAME_SYNC_AGENT_TRAVERSE_MO_TREE_PREORDER   "sync_agent_traverse_mo_tree_preorder"
  69
  70 #define API_NAME_SYNC_AGENT_EXPORT_TNDS_STREAM                  "sync_agent_export_tnds_stream"
  71 #define API_NAME_SYNC_AGENT_IMPORT_TNDS_STREAM                  "sync_agent_import_tnds_stream"
  72
  73 ///////////////////////////////////mo_executor.h//////////////////////////////////////////
  74 #define API_NAME_SYNC_AGENT_EXECUTE_MO_EXT                      "sync_agent_execute_mo_ext"
  75
  76 ///////////////////////////////////interface.h//////////////////////////////////////////
  77 #define API_NAME_SYNC_AGENT_START_MDM_SERVICE                   "sync_agent_start_mdm_service"
  78 #define API_NAME_SYNC_AGENT_STOP_MDM_SERVICE                    "sync_agent_stop_mdm_service"
  79 #define API_NAME_SYNC_AGENT_GET_MDM_SERVICE                     "sync_agent_get_mdm_service"
  80 #define API_NAME_SYNC_AGENT_SET_MDM_SERVICE                     "sync_agent_set_mdm_service"
  81 #define API_NAME_SYNC_AGENT_EXECUTE_MDM_SERVICE         "sync_agent_execute_mdm_service"
  82
  83 #define TNDS_SAMPLE_FILE "../../../testcase/fw-test-file/tnds_sample.txt"
  84
  85 static void utc_sync_agent_framework_sync_agent_create_mo_item_p(void);
  86 static void utc_sync_agent_framework_sync_agent_add_mo_item_p(void);
  87 static void utc_sync_agent_framework_sync_agent_add_mo_item_n(void);
  88 static void utc_sync_agent_framework_sync_agent_update_mo_item_p(void);
  89 static void utc_sync_agent_framework_sync_agent_update_mo_item_n(void);
  90 static void utc_sync_agent_framework_sync_agent_delete_mo_item_p(void);
  91 static void utc_sync_agent_framework_sync_agent_delete_mo_item_n(void);
  92 static void utc_sync_agent_framework_sync_agent_delete_mo_tree_item_p(void);
  93 static void utc_sync_agent_framework_sync_agent_delete_mo_tree_item_n(void);
  94 static void utc_sync_agent_framework_sync_agent_get_mo_item_p(void);
  95 static void utc_sync_agent_framework_sync_agent_get_mo_item_n(void);
  96 static void utc_sync_agent_framework_sync_agent_get_mo_items_p(void);
  97 static void utc_sync_agent_framework_sync_agent_get_mo_items_n(void);
  98 static void utc_sync_agent_framework_sync_agent_query_mo_item_p(void);
  99 static void utc_sync_agent_framework_sync_agent_qyery_mo_item_n(void);
 100 static void utc_sync_agent_framework_sync_agent_free_mo_item_p(void);
 101 static void utc_sync_agent_framework_sync_agent_free_mo_item_list_p(void);
 102 static void utc_sync_agent_framework_sync_agent_create_mo_acc_item_p(void);
 103 static void utc_sync_agent_framework_sync_agent_update_mo_acc_item_p(void);
 104 static void utc_sync_agent_framework_sync_agent_update_mo_acc_item_n(void);
 105 static void utc_sync_agent_framework_sync_agent_get_mo_acc_item_p(void);
 106 static void utc_sync_agent_framework_sync_agent_get_mo_acc_item_n(void);
 107 static void utc_sync_agent_framework_sync_agent_free_mo_acc_item_p(void);
 108
 109 static void utc_sync_agent_framework_sync_agent_initialize_p(void);
 110 static void utc_sync_agent_framework_sync_agent_initialize_n(void);
 111
 112 static void utc_sync_agent_framework_sync_agent_construct_mo_table_p(void);
 113 static void utc_sync_agent_framework_sync_agent_construct_mo_table_n(void);
 114
 115 static void utc_sync_agent_framework_sync_agent_uptodate_mo_table_p(void);
 116 static void utc_sync_agent_framework_sync_agent_uptodate_mo_table_n(void);
 117 static void utc_sync_agent_framework_sync_agent_delete_all_mo_table_p(void);
 118
 119 static void utc_sync_agent_framework_sync_agent_get_serverinfo_p(void);
 120 static void utc_sync_agent_framework_sync_agent_free_serverinfo_p(void);
 121
 122 static void utc_sync_agent_framework_sync_agent_get_serverid_p(void);
 123 static void utc_sync_agent_framework_sync_agent_get_serverid_n(void);
 124 static void utc_sync_agent_framework_sync_agent_get_root_path_p(void);
 125 static void utc_sync_agent_framework_sync_agent_get_root_path_n(void);
 126
 127 static void utc_sync_agent_framework_sync_agent_get_server_type_p(void);
 128 static void utc_sync_agent_framework_sync_agent_get_server_type_n(void);
 129
 130 static void utc_sync_agent_framework_sync_agent_is_exist_mo_p(void);
 131 static void utc_sync_agent_framework_sync_agent_is_exist_mo_n(void);
 132 static void utc_sync_agent_framework_sync_agent_get_mo_type_p(void);
 133 static void utc_sync_agent_framework_sync_agent_get_mo_type_n(void);
 134
 135 static void utc_sync_agent_framework_sync_agent_check_acl_value_p(void);
 136 static void utc_sync_agent_framework_sync_agent_check_acl_value_n(void);
 137 static void utc_sync_agent_framework_sync_agent_get_descendant_mo_tree_p(void);
 138 static void utc_sync_agent_framework_sync_agent_get_descendant_mo_tree_n(void);
 139 static void utc_sync_agent_framework_sync_agent_traverse_mo_tree_preorder_p(void);
 140 static void utc_sync_agent_framework_sync_agent_traverse_mo_tree_preorder_n(void);
 141
 142 static void utc_sync_agent_framework_sync_agent_export_tnds_stream_p(void);
 143 static void utc_sync_agent_framework_sync_agent_export_tnds_stream_n(void);
 144 static void utc_sync_agent_framework_sync_agent_import_tnds_stream_p(void);
 145 static void utc_sync_agent_framework_sync_agent_import_tnds_stream_n(void);
 146
 147 static void utc_sync_agent_framework_sync_agent_open_p(void);
 148 static void utc_sync_agent_framework_sync_agent_begin_transaction_mo_p(void);
 149 static void utc_sync_agent_framework_sync_agent_end_transaction_mo_p(void);
 150 static void utc_sync_agent_framework_sync_agent_close_p(void);
 151
 152 ///////////////////////////////////mo_executor.h//////////////////////////////////////////
 153
 154 static void utc_sync_agent_framework_sync_agent_execute_mo_ext_n(void);
 155
 156 ///////////////////////////////////mdm_control_code.h//////////////////////////////////////////
 157
 158 static void utc_sync_agent_framework_sync_agent_start_mdm_service_p(void);
 159 static void utc_sync_agent_framework_sync_agent_start_mdm_service_n(void);
 160 static void utc_sync_agent_framework_sync_agent_stop_mdm_service_p(void);
 161 static void utc_sync_agent_framework_sync_agent_stop_mdm_service_n(void);
 162 static void utc_sync_agent_framework_sync_agent_set_mdm_value_p(void);
 163 static void utc_sync_agent_framework_sync_agent_set_mdm_value_n(void);
 164 static void utc_sync_agent_framework_sync_agent_get_mdm_value_p(void);
 165 static void utc_sync_agent_framework_sync_agent_get_mdm_value_n(void);
 166 static void utc_sync_agent_framework_sync_agent_execute_mdm_p(void);
 167 static void utc_sync_agent_framework_sync_agent_execute_mdm_n(void);
 168
 169 struct tet_testlist tet_testlist[] = {
 170
 171         {utc_sync_agent_framework_sync_agent_create_mo_item_p, POSITIVE_TC_IDX},
 172         {utc_sync_agent_framework_sync_agent_add_mo_item_p, POSITIVE_TC_IDX},
 173         {utc_sync_agent_framework_sync_agent_add_mo_item_n, NEGATIVE_TC_IDX},
 174         {utc_sync_agent_framework_sync_agent_update_mo_item_p, POSITIVE_TC_IDX},
 175         {utc_sync_agent_framework_sync_agent_update_mo_item_n, NEGATIVE_TC_IDX},
 176         {utc_sync_agent_framework_sync_agent_delete_mo_item_p, POSITIVE_TC_IDX},
 177         {utc_sync_agent_framework_sync_agent_delete_mo_item_n, NEGATIVE_TC_IDX},
 178         {utc_sync_agent_framework_sync_agent_delete_mo_tree_item_p, POSITIVE_TC_IDX},
 179         {utc_sync_agent_framework_sync_agent_delete_mo_tree_item_n, NEGATIVE_TC_IDX},
 180         {utc_sync_agent_framework_sync_agent_get_mo_item_p, POSITIVE_TC_IDX},
 181         {utc_sync_agent_framework_sync_agent_get_mo_item_n, NEGATIVE_TC_IDX},
 182         {utc_sync_agent_framework_sync_agent_get_mo_items_p, POSITIVE_TC_IDX},
 183         {utc_sync_agent_framework_sync_agent_get_mo_items_n, NEGATIVE_TC_IDX},
 184         {utc_sync_agent_framework_sync_agent_query_mo_item_p, POSITIVE_TC_IDX},
 185         {utc_sync_agent_framework_sync_agent_qyery_mo_item_n, NEGATIVE_TC_IDX},
 186         {utc_sync_agent_framework_sync_agent_free_mo_item_p, POSITIVE_TC_IDX},
 187         {utc_sync_agent_framework_sync_agent_free_mo_item_list_p, POSITIVE_TC_IDX},
 188         {utc_sync_agent_framework_sync_agent_create_mo_acc_item_p, POSITIVE_TC_IDX},
 189         {utc_sync_agent_framework_sync_agent_update_mo_acc_item_p, POSITIVE_TC_IDX},
 190         {utc_sync_agent_framework_sync_agent_update_mo_acc_item_n, NEGATIVE_TC_IDX},
 191         {utc_sync_agent_framework_sync_agent_get_mo_acc_item_p, POSITIVE_TC_IDX},
 192         {utc_sync_agent_framework_sync_agent_get_mo_acc_item_n, NEGATIVE_TC_IDX},
 193         {utc_sync_agent_framework_sync_agent_free_mo_acc_item_p, POSITIVE_TC_IDX},
 194         {utc_sync_agent_framework_sync_agent_initialize_p, POSITIVE_TC_IDX},
 195         {utc_sync_agent_framework_sync_agent_initialize_n, NEGATIVE_TC_IDX},
 196         {utc_sync_agent_framework_sync_agent_construct_mo_table_p, POSITIVE_TC_IDX},
 197         {utc_sync_agent_framework_sync_agent_construct_mo_table_n, NEGATIVE_TC_IDX},
 198         {utc_sync_agent_framework_sync_agent_uptodate_mo_table_p, POSITIVE_TC_IDX},
 199         {utc_sync_agent_framework_sync_agent_uptodate_mo_table_n, NEGATIVE_TC_IDX},
 200         {utc_sync_agent_framework_sync_agent_delete_all_mo_table_p, POSITIVE_TC_IDX},
 201         {utc_sync_agent_framework_sync_agent_get_serverinfo_p, POSITIVE_TC_IDX},
 202         {utc_sync_agent_framework_sync_agent_free_serverinfo_p, POSITIVE_TC_IDX},
 203         {utc_sync_agent_framework_sync_agent_get_serverid_p, POSITIVE_TC_IDX},
 204         {utc_sync_agent_framework_sync_agent_get_serverid_n, NEGATIVE_TC_IDX},
 205         {utc_sync_agent_framework_sync_agent_get_root_path_p, POSITIVE_TC_IDX},
 206         {utc_sync_agent_framework_sync_agent_get_root_path_n, NEGATIVE_TC_IDX},
 207         {utc_sync_agent_framework_sync_agent_get_server_type_p, POSITIVE_TC_IDX},
 208         {utc_sync_agent_framework_sync_agent_get_server_type_n, NEGATIVE_TC_IDX},
 209         {utc_sync_agent_framework_sync_agent_is_exist_mo_p, POSITIVE_TC_IDX},
 210         {utc_sync_agent_framework_sync_agent_is_exist_mo_n, NEGATIVE_TC_IDX},
 211         {utc_sync_agent_framework_sync_agent_get_mo_type_p, POSITIVE_TC_IDX},
 212         {utc_sync_agent_framework_sync_agent_get_mo_type_n, NEGATIVE_TC_IDX},
 213         {utc_sync_agent_framework_sync_agent_check_acl_value_p, POSITIVE_TC_IDX},
 214         {utc_sync_agent_framework_sync_agent_check_acl_value_n, NEGATIVE_TC_IDX},
 215         {utc_sync_agent_framework_sync_agent_get_descendant_mo_tree_p, POSITIVE_TC_IDX},
 216         {utc_sync_agent_framework_sync_agent_get_descendant_mo_tree_n, NEGATIVE_TC_IDX},
 217         {utc_sync_agent_framework_sync_agent_traverse_mo_tree_preorder_p, POSITIVE_TC_IDX},
 218         {utc_sync_agent_framework_sync_agent_traverse_mo_tree_preorder_n, NEGATIVE_TC_IDX},
 219         {utc_sync_agent_framework_sync_agent_export_tnds_stream_p, POSITIVE_TC_IDX},
 220         {utc_sync_agent_framework_sync_agent_export_tnds_stream_n, NEGATIVE_TC_IDX},
 221         {utc_sync_agent_framework_sync_agent_import_tnds_stream_p, POSITIVE_TC_IDX},
 222         {utc_sync_agent_framework_sync_agent_import_tnds_stream_n, NEGATIVE_TC_IDX},
 223         {utc_sync_agent_framework_sync_agent_open_p, POSITIVE_TC_IDX},
 224         {utc_sync_agent_framework_sync_agent_begin_transaction_mo_p, POSITIVE_TC_IDX},
 225         {utc_sync_agent_framework_sync_agent_end_transaction_mo_p, POSITIVE_TC_IDX},
 226         {utc_sync_agent_framework_sync_agent_close_p, POSITIVE_TC_IDX},
 227         {utc_sync_agent_framework_sync_agent_execute_mo_ext_n, NEGATIVE_TC_IDX},
 228         {utc_sync_agent_framework_sync_agent_start_mdm_service_p, POSITIVE_TC_IDX},
 229         {utc_sync_agent_framework_sync_agent_start_mdm_service_n, NEGATIVE_TC_IDX},
 230         {utc_sync_agent_framework_sync_agent_set_mdm_value_p, POSITIVE_TC_IDX},
 231         {utc_sync_agent_framework_sync_agent_set_mdm_value_n, NEGATIVE_TC_IDX},
 232         {utc_sync_agent_framework_sync_agent_get_mdm_value_p, POSITIVE_TC_IDX},
 233         {utc_sync_agent_framework_sync_agent_get_mdm_value_n, NEGATIVE_TC_IDX},
 234         {utc_sync_agent_framework_sync_agent_execute_mdm_p, POSITIVE_TC_IDX},
 235         {utc_sync_agent_framework_sync_agent_execute_mdm_n, NEGATIVE_TC_IDX},
 236         {utc_sync_agent_framework_sync_agent_stop_mdm_service_p, POSITIVE_TC_IDX},
 237         {utc_sync_agent_framework_sync_agent_stop_mdm_service_n, NEGATIVE_TC_IDX},
 238
 239         {NULL, 0}
 240
 241 };
 242
 243 static void startup(void)
 244 {
 245         /* start of TC */
 246         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 247         sync_agent_init_error_e init_error = sync_agent_init(TEST_FW_CONFIG_FILE);
 248         if (init_error != SYNC_AGENT_INIT_SUCCESS) {
 249                 dts_message(API_NAME_SYNC_START_UP, "sync_agent_init : %d", init_error);
 250
 251                 err = sync_agent_open_mo();
 252                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 253                 }
 254
 255                 err = sync_agent_delete_all_mo_table();
 256                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 257                 } else {
 258                 }
 259
 260                 dts_fail(API_NAME_SYNC_START_UP);
 261         } else {
 262
 263                 err = sync_agent_open_mo();
 264                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 265                 }
 266
 267                 err = sync_agent_delete_all_mo_table();
 268                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 269                 } else {
 270                 }
 271
 272                 dts_pass(API_NAME_SYNC_START_UP);
 273         }
 274
 275 }
 276
 277 static void cleanup(void)
 278 {
 279         /* start of TC */
 280 }
 281
 282 static void utc_sync_agent_framework_sync_agent_create_mo_item_p(void)
 283 {
 284         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 285         sync_agent_dm_mo_node_s *sync_agent_mo_item = NULL;
 286         char *api_name = API_NAME_SYNC_AGENT_CREATE_MO_ITEM;
 287
 288         err = sync_agent_create_mo_item(&sync_agent_mo_item);
 289
 290         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 291                 dts_message(api_name, "sync_agent_framework : %d", err);
 292                 dts_fail(api_name);
 293         } else {
 294                 dts_pass(api_name);
 295         }
 296
 297         sync_agent_free_mo_item(sync_agent_mo_item);
 298 }
 299
 300 static void utc_sync_agent_framework_sync_agent_add_mo_item_p(void)
 301 {
 302         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 303         sync_agent_dm_mo_node_s sync_agent_mo_item;
 304         char *api_name = API_NAME_SYNC_AGENT_ADD_MO_ITEM;
 305
 306         sync_agent_mo_item.mo_type = 1;
 307         sync_agent_mo_item.full_path = "./dmacc/test1";
 308         sync_agent_mo_item.value = "aa";
 309         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
 310
 311         err = sync_agent_add_mo_item(&sync_agent_mo_item);
 312         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 313                 dts_message(api_name, "sync_agent_framework : %d", err);
 314
 315                 dts_fail(api_name);
 316         } else {
 317
 318                 dts_pass(api_name);
 319         }
 320
 321 }
 322
 323 static void utc_sync_agent_framework_sync_agent_add_mo_item_n(void)
 324 {
 325         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 326         sync_agent_dm_mo_node_s *sync_agent_mo_item = NULL;
 327         char *api_name = API_NAME_SYNC_AGENT_ADD_MO_ITEM;
 328
 329         err = sync_agent_add_mo_item(sync_agent_mo_item);
 330         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 331                 dts_message(api_name, "sync_agent_framework : %d", err);
 332
 333                 dts_fail(api_name);
 334         } else {
 335
 336                 dts_pass(api_name);
 337         }
 338
 339 }
 340
 341 static void utc_sync_agent_framework_sync_agent_update_mo_item_p(void)
 342 {
 343         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 344         sync_agent_dm_mo_node_s sync_agent_mo_item;
 345         char *api_name = API_NAME_SYNC_AGENT_UPDATE_MO_ITEM;
 346
 347         sync_agent_mo_item.mo_type = 1;
 348         sync_agent_mo_item.full_path = "./dmacc/test2";
 349         sync_agent_mo_item.value = "aa";
 350         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
 351
 352         err = sync_agent_add_mo_item(&sync_agent_mo_item);
 353         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 354                 dts_message(api_name, "sync_agent_framework : %d", err);
 355                 dts_fail(api_name);
 356         }
 357
 358         sync_agent_mo_item.value = "aaaa";
 359
 360         err = sync_agent_update_mo_item(&sync_agent_mo_item);
 361         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 362                 dts_message(api_name, "sync_agent_framework : %d", err);
 363
 364                 dts_fail(api_name);
 365         } else {
 366
 367                 dts_pass(api_name);
 368         }
 369
 370 }
 371
 372 static void utc_sync_agent_framework_sync_agent_update_mo_item_n(void)
 373 {
 374         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 375         sync_agent_dm_mo_node_s *sync_agent_mo_item = NULL;
 376         char *api_name = API_NAME_SYNC_AGENT_UPDATE_MO_ITEM;
 377
 378         err = sync_agent_update_mo_item(sync_agent_mo_item);
 379         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 380                 dts_message(api_name, "sync_agent_framework : %d", err);
 381
 382                 dts_fail(api_name);
 383         } else {
 384
 385                 dts_pass(api_name);
 386         }
 387
 388 }
 389
 390 static void utc_sync_agent_framework_sync_agent_delete_mo_item_p(void)
 391 {
 392         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 393         sync_agent_dm_mo_node_s sync_agent_mo_item;
 394         char *api_name = API_NAME_SYNC_AGENT_DELETE_MO_ITEM;
 395
 396         sync_agent_mo_item.mo_type = 1;
 397         sync_agent_mo_item.full_path = "./dmacc/test3";
 398         sync_agent_mo_item.value = "aa";
 399         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
 400
 401         err = sync_agent_add_mo_item(&sync_agent_mo_item);
 402         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 403                 dts_message(api_name, "sync_agent_framework : %d", err);
 404                 dts_fail(api_name);
 405         }
 406
 407         err = sync_agent_delete_mo_item("./dmacc/test3");
 408         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 409                 dts_message(api_name, "sync_agent_framework : %d", err);
 410
 411                 dts_fail(api_name);
 412         } else {
 413
 414                 dts_pass(api_name);
 415         }
 416 }
 417
 418 static void utc_sync_agent_framework_sync_agent_delete_mo_item_n(void)
 419 {
 420         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 421         char *api_name = API_NAME_SYNC_AGENT_DELETE_MO_ITEM;
 422
 423         err = sync_agent_delete_mo_item(NULL);
 424         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 425                 dts_message(api_name, "sync_agent_framework : %d", err);
 426
 427                 dts_fail(api_name);
 428         } else {
 429
 430                 dts_pass(api_name);
 431         }
 432
 433 }
 434
 435 static void utc_sync_agent_framework_sync_agent_delete_mo_tree_item_p(void)
 436 {
 437         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 438         sync_agent_dm_mo_node_s sync_agent_mo_item;
 439         char *api_name = API_NAME_SYNC_AGENT_DELETE_MO_TREE_ITEM;
 440
 441         sync_agent_mo_item.mo_type = 1;
 442         sync_agent_mo_item.full_path = "./dmacc/test4";
 443         sync_agent_mo_item.value = "aa";
 444         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
 445
 446         err = sync_agent_add_mo_item(&sync_agent_mo_item);
 447         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 448                 dts_message(api_name, "sync_agent_framework : %d", err);
 449                 dts_fail(api_name);
 450         }
 451
 452         err = sync_agent_delete_mo_tree_item("./dmacc/test4");
 453         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 454                 dts_message(api_name, "sync_agent_framework : %d", err);
 455
 456                 dts_fail(api_name);
 457         } else {
 458
 459                 dts_pass(api_name);
 460         }
 461
 462 }
 463
 464 static void utc_sync_agent_framework_sync_agent_delete_mo_tree_item_n(void)
 465 {
 466         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 467         char *api_name = API_NAME_SYNC_AGENT_DELETE_MO_ITEM;
 468
 469         err = sync_agent_delete_mo_tree_item(NULL);
 470         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 471                 dts_message(api_name, "sync_agent_framework : %d", err);
 472
 473                 dts_fail(api_name);
 474         } else {
 475
 476                 dts_pass(api_name);
 477         }
 478
 479 }
 480
 481 static void utc_sync_agent_framework_sync_agent_get_mo_item_p(void)
 482 {
 483         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 484         sync_agent_dm_mo_node_s sync_agent_mo_item;
 485         sync_agent_dm_mo_node_s *sync_agent_mo_items = NULL;
 486         char *api_name = API_NAME_SYNC_AGENT_GET_MO_ITEM;
 487
 488         sync_agent_mo_item.mo_type = 1;
 489         sync_agent_mo_item.full_path = "./dmacc/test5";
 490         sync_agent_mo_item.value = "aa";
 491         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
 492
 493         err = sync_agent_add_mo_item(&sync_agent_mo_item);
 494         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 495                 dts_message(api_name, "sync_agent_framework : %d", err);
 496                 dts_fail(api_name);
 497         }
 498
 499         err = sync_agent_get_mo_item("./dmacc/test5", &sync_agent_mo_items);
 500         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 501                 dts_message(api_name, "sync_agent_framework : %d", err);
 502
 503                 dts_fail(api_name);
 504         } else {
 505
 506                 dts_pass(api_name);
 507         }
 508
 509 }
 510
 511 static void utc_sync_agent_framework_sync_agent_get_mo_item_n(void)
 512 {
 513         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 514         sync_agent_dm_mo_node_s *sync_agent_mo_items = NULL;
 515         char *api_name = API_NAME_SYNC_AGENT_GET_MO_ITEM;
 516
 517         err = sync_agent_get_mo_item(NULL, &sync_agent_mo_items);
 518         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 519                 dts_message(api_name, "sync_agent_framework : %d", err);
 520                 dts_fail(api_name);
 521         } else {
 522                 dts_pass(api_name);
 523         }
 524
 525 }
 526
 527 static void utc_sync_agent_framework_sync_agent_get_mo_items_p(void)
 528 {
 529         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 530         sync_agent_dm_mo_node_s sync_agent_mo_item;
 531         sync_agent_dm_mo_node_s *sync_agent_mo_items = NULL;
 532         char *api_name = API_NAME_SYNC_AGENT_GET_MO_ITEMS;
 533
 534         sync_agent_mo_item.mo_type = 1;
 535         sync_agent_mo_item.full_path = "./dmacc/test6";
 536         sync_agent_mo_item.value = "aa";
 537         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
 538
 539         err = sync_agent_add_mo_item(&sync_agent_mo_item);
 540         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 541                 dts_message(api_name, "sync_agent_framework : %d", err);
 542                 dts_fail(api_name);
 543         }
 544
 545         err = sync_agent_get_mo_items("./dmacc/test6", &sync_agent_mo_items);
 546         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 547                 dts_message(api_name, "sync_agent_framework : %d", err);
 548
 549                 dts_fail(api_name);
 550         } else {
 551
 552                 dts_pass(api_name);
 553         }
 554
 555 }
 556
 557 static void utc_sync_agent_framework_sync_agent_get_mo_items_n(void)
 558 {
 559         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 560         sync_agent_dm_mo_node_s *sync_agent_mo_items = NULL;
 561         char *api_name = API_NAME_SYNC_AGENT_GET_MO_ITEMS;
 562
 563         err = sync_agent_get_mo_items(NULL, &sync_agent_mo_items);
 564         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 565                 dts_message(api_name, "sync_agent_framework : %d", err);
 566
 567                 dts_fail(api_name);
 568         } else {
 569
 570                 dts_pass(api_name);
 571         }
 572
 573 }
 574
 575 static void utc_sync_agent_framework_sync_agent_query_mo_item_p(void)
 576 {
 577         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 578         sync_agent_dm_mo_node_s sync_agent_mo_item;
 579         char *api_name = API_NAME_SYNC_AGENT_QUERY_MO_ITEM;
 580         sync_agent_dm_mo_item_s sync_agent_mo_query;
 581         GList *list = NULL;
 582
 583         sync_agent_mo_item.mo_type = 1;
 584         sync_agent_mo_item.full_path = "./dmacc/test7";
 585         sync_agent_mo_item.value = "aa";
 586         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
 587
 588         err = sync_agent_add_mo_item(&sync_agent_mo_item);
 589         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 590                 dts_message(api_name, "sync_agent_framework : %d", err);
 591                 dts_fail(api_name);
 592         }
 593
 594         sync_agent_mo_query.mo_path = "./dmacc/test7";
 595         sync_agent_mo_query.interface_type = MO_ONLY_DATA_VALUE;
 596         sync_agent_mo_query.mo_type = 1;
 597         sync_agent_mo_query.option = SYNC_AGENT_DM_MO_GET_OPTION_NODE;
 598
 599         err = sync_agent_query_mo_item(&sync_agent_mo_query, &list);
 600         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 601                 dts_message(api_name, "sync_agent_framework : %d", err);
 602
 603                 dts_fail(api_name);
 604         } else {
 605
 606                 dts_pass(api_name);
 607         }
 608
 609 }
 610
 611 static void utc_sync_agent_framework_sync_agent_qyery_mo_item_n(void)
 612 {
 613         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 614         sync_agent_dm_mo_node_s *sync_agent_mo_items = NULL;
 615         char *api_name = API_NAME_SYNC_AGENT_QUERY_MO_ITEM;
 616         sync_agent_dm_mo_item_s *sync_agent_mo_query = NULL;
 617         GList *list = NULL;
 618
 619         err = sync_agent_query_mo_item(sync_agent_mo_query, &list);
 620         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 621                 dts_message(api_name, "sync_agent_framework : %d", err);
 622
 623                 dts_fail(api_name);
 624         } else {
 625
 626                 dts_pass(api_name);
 627         }
 628
 629 }
 630
 631 static void utc_sync_agent_framework_sync_agent_free_mo_item_p(void)
 632 {
 633         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 634         sync_agent_dm_mo_node_s *sync_agent_mo_item = NULL;
 635         char *api_name = API_NAME_SYNC_AGENT_FREE_MO_ITEM;
 636
 637         err = sync_agent_create_mo_item(&sync_agent_mo_item);
 638         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 639                 dts_message(api_name, "sync_agent_framework : %d", err);
 640                 dts_fail(api_name);
 641         }
 642
 643         sync_agent_free_mo_item(sync_agent_mo_item);
 644         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 645                 dts_message(api_name, "sync_agent_framework : %d", err);
 646
 647                 dts_fail(api_name);
 648         } else {
 649
 650                 dts_pass(api_name);
 651         }
 652
 653 }
 654
 655 static void utc_sync_agent_framework_sync_agent_free_mo_item_list_p(void)
 656 {
 657         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 658         sync_agent_dm_mo_node_s *sync_agent_mo_item = NULL;
 659         char *api_name = API_NAME_SYNC_AGENT_FREE_MO_ITEM;
 660         GList *list = NULL;
 661
 662         err = sync_agent_create_mo_item(&sync_agent_mo_item);
 663         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 664                 dts_message(api_name, "sync_agent_framework : %d", err);
 665                 dts_fail(api_name);
 666         }
 667
 668         list = g_list_append(list, sync_agent_mo_item);
 669
 670         sync_agent_free_mo_item_list(list);
 671         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 672                 dts_message(api_name, "sync_agent_framework : %d", err);
 673
 674                 dts_fail(api_name);
 675         } else {
 676
 677                 dts_pass(api_name);
 678         }
 679
 680 }
 681
 682 static void utc_sync_agent_framework_sync_agent_create_mo_acc_item_p(void)
 683 {
 684         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 685         char *api_name = API_NAME_SYNC_AGENT_CREATE_MO_ACC_ITEM;
 686         sync_agent_dm_acc_info_s *acc_info = NULL;
 687
 688         err = sync_agent_create_mo_acc_item(&acc_info);
 689         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 690                 dts_message(api_name, "sync_agent_framework : %d", err);
 691                 dts_fail(api_name);
 692         } else {
 693                 dts_pass(api_name);
 694         }
 695
 696         sync_agent_free_mo_acc_item(&acc_info);
 697
 698 }
 699
 700 static void utc_sync_agent_framework_sync_agent_update_mo_acc_item_p(void)
 701 {
 702         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 703         char *api_name = API_NAME_SYNC_AGENT_UPDATE_MO_ACC_ITEM;
 704         sync_agent_dm_acc_info_s acc_info;
 705         sync_agent_dm_mo_acc_item_info_s sync_agent_mo_acc_info_item;
 706
 707         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
 708         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
 709         int mo_plugin_id = 4;
 710         int server_type = 16;
 711
 712         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
 713         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 714                 dts_message(api_name, "sync_agent_framework : %d", err);
 715                 dts_fail(api_name);
 716         }
 717
 718         sync_agent_mo_acc_info_item.serverid = "RSate";
 719         sync_agent_mo_acc_info_item.acc_type = DEVICE_MANAGE_ACC_TYPE_SERVER;
 720
 721         acc_info.auth_type = "xxx";
 722         acc_info.auth_secret = "xxx";
 723         acc_info.auth_name = "xxxx";
 724         acc_info.auth_level = "xxx";
 725         acc_info.auth_data = "xxx";
 726         acc_info.addr = "xxxxx";
 727
 728         err = sync_agent_update_mo_acc_item(&sync_agent_mo_acc_info_item, &acc_info);
 729         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 730                 dts_message(api_name, "sync_agent_framework : %d", err);
 731
 732                 err = sync_agent_delete_mo_tree_item("./DMAcc");
 733                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 734                         dts_message(api_name, "sync_agent_framework : %d", err);
 735                         dts_fail(api_name);
 736                 }
 737
 738                 dts_fail(api_name);
 739         } else {
 740
 741                 err = sync_agent_delete_mo_tree_item("./DMAcc");
 742                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 743                         dts_message(api_name, "sync_agent_framework : %d", err);
 744                         dts_fail(api_name);
 745                 }
 746
 747                 dts_pass(api_name);
 748         }
 749 }
 750
 751 static void utc_sync_agent_framework_sync_agent_update_mo_acc_item_n(void)
 752 {
 753         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 754         char *api_name = API_NAME_SYNC_AGENT_UPDATE_MO_ACC_ITEM;
 755         sync_agent_dm_acc_info_s acc_info;
 756         sync_agent_dm_mo_acc_item_info_s *sync_agent_mo_acc_info_item = NULL;
 757
 758         err = sync_agent_update_mo_acc_item(sync_agent_mo_acc_info_item, &acc_info);
 759         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 760                 dts_message(api_name, "sync_agent_framework : %d", err);
 761                 dts_fail(api_name);
 762         } else {
 763                 dts_pass(api_name);
 764         }
 765
 766 }
 767
 768 static void utc_sync_agent_framework_sync_agent_get_mo_acc_item_p(void)
 769 {
 770         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 771         char *api_name = API_NAME_SYNC_AGENT_GET_MO_ACC_ITEM;
 772
 773         sync_agent_dm_acc_info_s *acc_info = NULL;
 774         sync_agent_dm_mo_acc_item_info_s sync_agent_mo_acc_info_item;
 775
 776         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
 777         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
 778         int mo_plugin_id = 4;
 779         int server_type = 16;
 780
 781         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
 782         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 783                 dts_message(api_name, "sync_agent_framework : %d", err);
 784                 dts_fail(api_name);
 785         }
 786
 787         sync_agent_mo_acc_info_item.serverid = "RSate";
 788         sync_agent_mo_acc_info_item.acc_type = DEVICE_MANAGE_ACC_TYPE_SERVER;
 789
 790         err = sync_agent_get_mo_acc_item(&sync_agent_mo_acc_info_item, &acc_info);
 791         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 792                 dts_message(api_name, "sync_agent_framework : %d", err);
 793
 794                 err = sync_agent_delete_mo_tree_item("./DMAcc");
 795                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 796                         dts_message(api_name, "sync_agent_framework : %d", err);
 797                         dts_fail(api_name);
 798                 }
 799
 800                 dts_fail(api_name);
 801         } else {
 802
 803                 err = sync_agent_delete_mo_tree_item("./DMAcc");
 804                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 805                         dts_message(api_name, "sync_agent_framework : %d", err);
 806                         dts_fail(api_name);
 807                 }
 808
 809                 dts_pass(api_name);
 810         }
 811
 812 }
 813
 814 static void utc_sync_agent_framework_sync_agent_get_mo_acc_item_n(void)
 815 {
 816         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 817         char *api_name = API_NAME_SYNC_AGENT_GET_MO_ACC_ITEM;
 818         sync_agent_dm_acc_info_s *acc_info = NULL;
 819         sync_agent_dm_mo_acc_item_info_s *sync_agent_mo_acc_info_item = NULL;
 820
 821         err = sync_agent_get_mo_acc_item(sync_agent_mo_acc_info_item, &acc_info);
 822         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 823                 dts_message(api_name, "sync_agent_framework : %d", err);
 824                 dts_fail(api_name);
 825         } else {
 826                 dts_pass(api_name);
 827         }
 828
 829         err = sync_agent_close_mo();
 830         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 831                 dts_message(api_name, "sync_agent_framework : %d", err);
 832                 dts_fail(api_name);
 833         }
 834 }
 835
 836 static void utc_sync_agent_framework_sync_agent_free_mo_acc_item_p(void)
 837 {
 838         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 839         char *api_name = API_NAME_SYNC_AGENT_FREE_MO_ACC_ITEM;
 840         sync_agent_dm_acc_info_s *acc_info = NULL;
 841
 842         err = sync_agent_create_mo_acc_item(&acc_info);
 843         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 844                 dts_message(api_name, "sync_agent_framework : %d", err);
 845                 dts_fail(api_name);
 846         }
 847
 848         err = sync_agent_free_mo_acc_item(&acc_info);
 849         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 850                 dts_message(api_name, "sync_agent_framework : %d", err);
 851                 dts_fail(api_name);
 852         } else {
 853                 dts_pass(api_name);
 854         }
 855
 856         err = sync_agent_close_mo();
 857         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 858                 dts_message(api_name, "sync_agent_framework : %d", err);
 859                 dts_fail(api_name);
 860         }
 861 }
 862
 863 static void utc_sync_agent_framework_sync_agent_initialize_p(void)
 864 {
 865         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 866         char *api_name = API_NAME_SYNC_AGENT_INITIALIZE;
 867         int mo_plugin_id = 8;
 868
 869         err = sync_agent_initialize_mo(mo_plugin_id);
 870         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 871                 dts_message(api_name, "sync_agent_framework : %d", err);
 872                 dts_fail(api_name);
 873         } else {
 874                 dts_pass(api_name);
 875         }
 876 }
 877
 878 static void utc_sync_agent_framework_sync_agent_initialize_n(void)
 879 {
 880         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 881         char *api_name = API_NAME_SYNC_AGENT_INITIALIZE;
 882         int mo_plugin_id = 100;
 883
 884         err = sync_agent_initialize_mo(mo_plugin_id);
 885         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 886                 dts_message(api_name, "sync_agent_framework : %d", err);
 887                 dts_fail(api_name);
 888         } else {
 889                 dts_pass(api_name);
 890         }
 891 }
 892
 893 static void utc_sync_agent_framework_sync_agent_begin_transaction_mo_p(void)
 894 {
 895         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 896         char *api_name = API_NAME_SYNC_AGENT_CLOSE;
 897
 898         err = sync_agent_begin_transaction_mo();
 899         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 900                 dts_message(api_name, "sync_agent_framework : %d", err);
 901
 902                 dts_fail(api_name);
 903         } else {
 904
 905                 err = sync_agent_end_transaction_mo(SYNC_AGENT_DM_MO_TRANSACTION_COMMIT);
 906                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 907                         dts_message(api_name, "sync_agent_framework : %d", err);
 908                         dts_fail(api_name);
 909                 }
 910
 911                 dts_pass(api_name);
 912         }
 913
 914 }
 915
 916 static void utc_sync_agent_framework_sync_agent_end_transaction_mo_p(void)
 917 {
 918         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 919         char *api_name = API_NAME_SYNC_AGENT_CLOSE;
 920
 921         err = sync_agent_begin_transaction_mo();
 922         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 923                 dts_message(api_name, "sync_agent_framework : %d", err);
 924                 dts_fail(api_name);
 925         } else {
 926                 dts_pass(api_name);
 927         }
 928
 929         //db control
 930
 931         err = sync_agent_end_transaction_mo(SYNC_AGENT_DM_MO_TRANSACTION_COMMIT);
 932         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 933                 dts_message(api_name, "sync_agent_framework : %d", err);
 934
 935                 dts_fail(api_name);
 936         } else {
 937
 938                 dts_pass(api_name);
 939         }
 940
 941 }
 942
 943 static void utc_sync_agent_framework_sync_agent_construct_mo_table_p(void)
 944 {
 945         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 946         char *api_name = API_NAME_SYNC_AGENT_CONSTRUCT_MO_TABLE;
 947
 948         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
 949         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
 950         int mo_plugin_id = 4;
 951         int server_type = 16;
 952
 953         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
 954         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 955                 dts_message(api_name, "sync_agent_framework : %d", err);
 956
 957                 err = sync_agent_delete_mo_tree_item("./DMAcc");
 958                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 959                         dts_message(api_name, "sync_agent_framework : %d", err);
 960                         dts_fail(api_name);
 961                 }
 962
 963                 dts_fail(api_name);
 964         } else {
 965
 966                 err = sync_agent_delete_mo_tree_item("./DMAcc");
 967                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
 968                         dts_message(api_name, "sync_agent_framework : %d", err);
 969                         dts_fail(api_name);
 970                 }
 971
 972                 dts_pass(api_name);
 973         }
 974
 975 }
 976
 977 static void utc_sync_agent_framework_sync_agent_construct_mo_table_n(void)
 978 {
 979         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
 980         char *api_name = API_NAME_SYNC_AGENT_CONSTRUCT_MO_TABLE;
 981
 982         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
 983         const char *vendar_file = NULL;
 984         int mo_plugin_id = 4;
 985         int server_type = 16;
 986
 987         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
 988         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
 989                 dts_message(api_name, "sync_agent_framework : %d", err);
 990
 991                 dts_fail(api_name);
 992         } else {
 993
 994                 dts_pass(api_name);
 995         }
 996
 997 }
 998
 999 static void utc_sync_agent_framework_sync_agent_uptodate_mo_table_p(void)
1000 {
1001         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1002         char *api_name = API_NAME_SYNC_AGENT_UPTODATE_MO_TABLE;
1003
1004         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1005         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
1006         int mo_plugin_id = 4;
1007         int server_type = 16;
1008
1009         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
1010         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1011                 dts_message(api_name, "sync_agent_framework : %d", err);
1012                 dts_fail(api_name);
1013         }
1014
1015         err = sync_agent_uptodate_mo_table(mo_type, mo_plugin_id, "./DMAcc/gcf");
1016         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1017                 dts_message(api_name, "sync_agent_framework : %d", err);
1018
1019                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1020                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1021                         dts_message(api_name, "sync_agent_framework : %d", err);
1022                         dts_fail(api_name);
1023                 }
1024                 dts_fail(api_name);
1025         } else {
1026
1027                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1028                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1029                         dts_message(api_name, "sync_agent_framework : %d", err);
1030                         dts_fail(api_name);
1031                 }
1032                 dts_pass(api_name);
1033         }
1034
1035 }
1036
1037 static void utc_sync_agent_framework_sync_agent_uptodate_mo_table_n(void)
1038 {
1039         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1040         char *api_name = API_NAME_SYNC_AGENT_UPTODATE_MO_TABLE;
1041
1042         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1043         int mo_plugin_id = 4;
1044
1045         err = sync_agent_uptodate_mo_table(mo_type, mo_plugin_id, NULL);
1046         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1047                 dts_message(api_name, "sync_agent_framework : %d", err);
1048
1049                 dts_fail(api_name);
1050         } else {
1051
1052                 dts_pass(api_name);
1053         }
1054
1055 }
1056
1057 static void utc_sync_agent_framework_sync_agent_delete_all_mo_table_p(void)
1058 {
1059         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1060         char *api_name = API_NAME_SYNC_AGENT_DELETE_ALL_MO_TABLE;
1061
1062         err = sync_agent_delete_all_mo_table();
1063         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1064                 dts_message(api_name, "sync_agent_framework : %d", err);
1065                 dts_fail(api_name);
1066         } else {
1067                 dts_pass(api_name);
1068         }
1069
1070 }
1071
1072 static void utc_sync_agent_framework_sync_agent_get_serverinfo_p(void)
1073 {
1074         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1075         char *api_name = API_NAME_SYNC_AGENT_GET_SERVERINFO;
1076         sync_agent_dm_server_info_s *server_info = NULL;
1077
1078         err = sync_agent_get_serverinfo(&server_info);
1079         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1080                 dts_message(api_name, "sync_agent_framework : %d", err);
1081                 err = sync_agent_free_serverinfo(server_info);
1082                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1083                         dts_message(api_name, "sync_agent_framework : %d", err);
1084                         dts_fail(api_name);
1085                 }
1086
1087                 dts_fail(api_name);
1088         } else {
1089                 dts_pass(api_name);
1090         }
1091
1092 }
1093
1094 static void utc_sync_agent_framework_sync_agent_free_serverinfo_p(void)
1095 {
1096         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1097         char *api_name = API_NAME_SYNC_AGENT_FREE_SERVERINFO;
1098         sync_agent_dm_server_info_s *server_info = NULL;
1099
1100         err = sync_agent_get_serverinfo(&server_info);
1101         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1102                 dts_message(api_name, "sync_agent_framework : %d", err);
1103                 dts_fail(api_name);
1104         }
1105
1106         err = sync_agent_free_serverinfo(server_info);
1107         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1108                 dts_message(api_name, "sync_agent_framework : %d", err);
1109                 dts_fail(api_name);
1110         } else {
1111                 dts_pass(api_name);
1112         }
1113
1114 }
1115
1116 static void utc_sync_agent_framework_sync_agent_get_serverid_p(void)
1117 {
1118         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1119         char *api_name = API_NAME_SYNC_AGENT_GET_SERVERID;
1120         char *server_id = NULL;
1121
1122         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1123         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
1124         int mo_plugin_id = 4;
1125         int server_type = 16;
1126
1127         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
1128         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1129                 dts_message(api_name, "sync_agent_framework : %d", err);
1130                 dts_fail(api_name);
1131         }
1132
1133         err = sync_agent_get_serverid(mo_type, &server_id);
1134         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1135                 dts_message(api_name, "sync_agent_framework : %d", err);
1136
1137                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1138                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1139                         dts_message(api_name, "sync_agent_framework : %d", err);
1140                         dts_fail(api_name);
1141                 }
1142
1143                 dts_fail(api_name);
1144         } else {
1145
1146                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1147                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1148                         dts_message(api_name, "sync_agent_framework : %d", err);
1149                         dts_fail(api_name);
1150                 }
1151
1152                 dts_pass(api_name);
1153         }
1154
1155 }
1156
1157 static void utc_sync_agent_framework_sync_agent_get_serverid_n(void)
1158 {
1159         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1160         char *api_name = API_NAME_SYNC_AGENT_GET_SERVERID;
1161         sync_agent_dm_mo_type_e mo_type = 16;
1162         char *server_id = NULL;
1163
1164         err = sync_agent_get_serverid(mo_type, &server_id);
1165         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1166                 dts_message(api_name, "sync_agent_framework : %d", err);
1167
1168                 dts_fail(api_name);
1169         } else {
1170
1171                 dts_pass(api_name);
1172         }
1173
1174 }
1175
1176 static void utc_sync_agent_framework_sync_agent_get_root_path_p(void)
1177 {
1178         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1179         char *api_name = API_NAME_SYNC_AGENT_GET_ROOT_PATH;
1180         char *mo_full_path = NULL;
1181         char *root_path = NULL;
1182
1183         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1184         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
1185         int mo_plugin_id = 4;
1186         int server_type = 16;
1187
1188         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
1189         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1190                 dts_message(api_name, "sync_agent_framework : %d", err);
1191                 dts_fail(api_name);
1192         }
1193
1194         mo_full_path = "./DMAcc/gcf/Name";
1195
1196         err = sync_agent_get_root_path(mo_full_path, &root_path);
1197         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1198                 dts_message(api_name, "sync_agent_framework : %d", err);
1199
1200                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1201                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1202                         dts_message(api_name, "sync_agent_framework : %d", err);
1203                         dts_fail(api_name);
1204                 }
1205
1206                 dts_fail(api_name);
1207         } else {
1208
1209                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1210                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1211                         dts_message(api_name, "sync_agent_framework : %d", err);
1212                         dts_fail(api_name);
1213                 }
1214
1215                 dts_pass(api_name);
1216         }
1217
1218 }
1219
1220 static void utc_sync_agent_framework_sync_agent_get_root_path_n(void)
1221 {
1222         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1223         char *api_name = API_NAME_SYNC_AGENT_GET_ROOT_PATH;
1224         char *mo_full_path = NULL;
1225         char *root_path = NULL;
1226
1227         err = sync_agent_get_root_path(mo_full_path, &root_path);
1228         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1229                 dts_message(api_name, "sync_agent_framework : %d", err);
1230
1231                 dts_fail(api_name);
1232         } else {
1233
1234                 dts_pass(api_name);
1235         }
1236
1237 }
1238
1239 static void utc_sync_agent_framework_sync_agent_get_server_type_p(void)
1240 {
1241         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1242         char *api_name = API_NAME_SYNC_AGENT_GET_SERVER_TYPE;
1243         char *server_id = NULL;
1244
1245         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1246         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
1247         int mo_plugin_id = 4;
1248         int server_type = 16;
1249
1250         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
1251         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1252                 dts_message(api_name, "sync_agent_framework : %d", err);
1253                 dts_fail(api_name);
1254         }
1255
1256         server_id = "RSate";
1257
1258         err = sync_agent_get_server_type(server_id, &server_type);
1259         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1260                 dts_message(api_name, "sync_agent_framework : %d", err);
1261
1262                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1263                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1264                         dts_message(api_name, "sync_agent_framework : %d", err);
1265                         dts_fail(api_name);
1266                 }
1267
1268                 dts_fail(api_name);
1269         } else {
1270
1271                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1272                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1273                         dts_message(api_name, "sync_agent_framework : %d", err);
1274                         dts_fail(api_name);
1275                 }
1276
1277                 dts_pass(api_name);
1278         }
1279
1280 }
1281
1282 static void utc_sync_agent_framework_sync_agent_get_server_type_n(void)
1283 {
1284         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1285         char *api_name = API_NAME_SYNC_AGENT_GET_SERVER_TYPE;
1286         char *server_id = NULL;
1287         int server_type = 0;
1288
1289         err = sync_agent_get_server_type(server_id, &server_type);
1290         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1291                 dts_message(api_name, "sync_agent_framework : %d", err);
1292
1293                 dts_fail(api_name);
1294         } else {
1295
1296                 dts_pass(api_name);
1297         }
1298
1299 }
1300
1301 static void utc_sync_agent_framework_sync_agent_is_exist_mo_p(void)
1302 {
1303         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1304         char *api_name = API_NAME_SYNC_AGENT_GET_SERVER_TYPE;
1305         char *mo_path = NULL;
1306         int is_exist = 0;
1307
1308         sync_agent_dm_mo_node_s sync_agent_mo_item;
1309
1310         sync_agent_mo_item.mo_type = 1;
1311         sync_agent_mo_item.full_path = "./dmacc/test8";
1312         sync_agent_mo_item.value = "aa";
1313         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
1314
1315         err = sync_agent_add_mo_item(&sync_agent_mo_item);
1316         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1317                 dts_message(api_name, "sync_agent_framework : %d", err);
1318                 dts_fail(api_name);
1319         }
1320
1321         mo_path = "./dmacc/test8";
1322
1323         err = sync_agent_is_exist_mo(mo_path, &is_exist);
1324         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1325                 dts_message(api_name, "sync_agent_framework : %d", err);
1326
1327                 dts_fail(api_name);
1328         } else {
1329
1330                 dts_pass(api_name);
1331         }
1332
1333 }
1334
1335 static void utc_sync_agent_framework_sync_agent_is_exist_mo_n(void)
1336 {
1337         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1338         char *api_name = API_NAME_SYNC_AGENT_GET_SERVER_TYPE;
1339         char *mo_path = NULL;
1340         int is_exist = 0;
1341
1342         err = sync_agent_is_exist_mo(mo_path, &is_exist);
1343         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1344                 dts_message(api_name, "sync_agent_framework : %d", err);
1345
1346                 dts_fail(api_name);
1347         } else {
1348
1349                 dts_pass(api_name);
1350         }
1351
1352 }
1353
1354 static void utc_sync_agent_framework_sync_agent_get_mo_type_p(void)
1355 {
1356         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1357         char *api_name = API_NAME_SYNC_AGENT_GET_MO_TYPE;
1358         char *mo_full_path = NULL;
1359         sync_agent_dm_mo_type_e mo_type = 0;
1360         sync_agent_dm_mo_node_s sync_agent_mo_item;
1361
1362         sync_agent_mo_item.mo_type = 1;
1363         sync_agent_mo_item.full_path = "./dmacc/test9";
1364         sync_agent_mo_item.value = "aa";
1365         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
1366
1367         err = sync_agent_add_mo_item(&sync_agent_mo_item);
1368         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1369                 dts_message(api_name, "sync_agent_framework : %d", err);
1370                 dts_fail(api_name);
1371         }
1372
1373         mo_full_path = "./dmacc/test9";
1374
1375         err = sync_agent_get_mo_type(mo_full_path, &mo_type);
1376         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1377                 dts_message(api_name, "sync_agent_framework : %d", err);
1378
1379                 dts_fail(api_name);
1380         } else {
1381
1382                 dts_pass(api_name);
1383         }
1384
1385 }
1386
1387 static void utc_sync_agent_framework_sync_agent_get_mo_type_n(void)
1388 {
1389         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1390         char *api_name = API_NAME_SYNC_AGENT_GET_MO_TYPE;
1391         char *mo_full_path = NULL;
1392         sync_agent_dm_mo_type_e mo_type = 0;
1393
1394         err = sync_agent_get_mo_type(mo_full_path, &mo_type);
1395         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1396                 dts_message(api_name, "sync_agent_framework : %d", err);
1397
1398                 dts_fail(api_name);
1399         } else {
1400
1401                 dts_pass(api_name);
1402         }
1403
1404 }
1405
1406 static void utc_sync_agent_framework_sync_agent_check_acl_value_p(void)
1407 {
1408         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1409         char *api_name = API_NAME_SYNC_AGENT_CHECK_ACL_VALUE;
1410
1411         sync_agent_dm_mo_node_s sync_agent_mo_item;
1412         sync_agent_dm_mo_runtime_property_s *runtime_property = NULL;
1413         sync_agent_dm_mo_access_type_e access_type = SYNC_AGENT_DM_MO_ACCESSTYPE_GET;
1414         char *mo_full_path = NULL;
1415         char *server_id = NULL;
1416         int check_acl = 0;
1417
1418         runtime_property = (sync_agent_dm_mo_runtime_property_s *) calloc(1, sizeof(sync_agent_dm_mo_runtime_property_s) + 1);
1419         if (runtime_property == NULL) {
1420                 dts_message(api_name, "sync_agent_framework : %d", err);
1421                 dts_fail(api_name);
1422         }
1423
1424         runtime_property->acl = "Get=RSate&Replace=RSate";
1425
1426         sync_agent_mo_item.mo_type = 1;
1427         sync_agent_mo_item.full_path = "./dmacc/test10";
1428         sync_agent_mo_item.value = "aa";
1429         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
1430         sync_agent_mo_item.runtime_property = runtime_property;
1431
1432         err = sync_agent_add_mo_item(&sync_agent_mo_item);
1433         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1434                 dts_message(api_name, "sync_agent_framework : %d", err);
1435
1436                 free(runtime_property);
1437                 dts_fail(api_name);
1438         }
1439
1440         mo_full_path = "./dmacc/test10";
1441         server_id = "RSate";
1442
1443         err = sync_agent_check_acl_value(mo_full_path, access_type, server_id, &check_acl);
1444         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1445                 dts_message(api_name, "sync_agent_framework : %d", err);
1446
1447                 free(runtime_property);
1448                 dts_fail(api_name);
1449         } else {
1450
1451                 free(runtime_property);
1452                 dts_pass(api_name);
1453         }
1454
1455 }
1456
1457 static void utc_sync_agent_framework_sync_agent_check_acl_value_n(void)
1458 {
1459         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1460         char *api_name = API_NAME_SYNC_AGENT_CHECK_ACL_VALUE;
1461
1462         sync_agent_dm_mo_access_type_e access_type = SYNC_AGENT_DM_MO_ACCESSTYPE_GET;
1463         char *mo_full_path = NULL;
1464         char *server_id = NULL;
1465         int check_acl = 0;
1466
1467         server_id = "RSate";
1468
1469         err = sync_agent_check_acl_value(mo_full_path, access_type, server_id, &check_acl);
1470         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1471                 dts_message(api_name, "sync_agent_framework : %d", err);
1472                 dts_fail(api_name);
1473         } else {
1474
1475                 dts_pass(api_name);
1476         }
1477
1478 }
1479
1480 static void utc_sync_agent_framework_sync_agent_get_descendant_mo_tree_p(void)
1481 {
1482         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1483         char *api_name = API_NAME_SYNC_AGENT_DESCENDANT_MO_TREE;
1484
1485         char *mo_full_path = NULL;
1486         sync_agent_dm_mo_node_s *root_node = NULL;
1487         int count = 0;
1488
1489         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1490         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
1491         int mo_plugin_id = 4;
1492         int server_type = 16;
1493
1494         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
1495         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1496                 dts_message(api_name, "sync_agent_framework : %d", err);
1497                 dts_fail(api_name);
1498         }
1499
1500         mo_full_path = "./DMAcc/gcf/Name";
1501
1502         err = sync_agent_get_descendant_mo_tree(mo_type, mo_full_path, &root_node, &count, SYNC_AGENT_DM_MO_GET_OPTION_NODE);
1503         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1504                 dts_message(api_name, "sync_agent_framework : %d", err);
1505
1506                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1507                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1508                         dts_message(api_name, "sync_agent_framework : %d", err);
1509                         dts_fail(api_name);
1510                 }
1511
1512         } else {
1513
1514                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1515                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1516                         dts_message(api_name, "sync_agent_framework : %d", err);
1517                         dts_fail(api_name);
1518                 }
1519
1520                 dts_pass(api_name);
1521         }
1522
1523 }
1524
1525 static void utc_sync_agent_framework_sync_agent_get_descendant_mo_tree_n(void)
1526 {
1527         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1528         char *api_name = API_NAME_SYNC_AGENT_DESCENDANT_MO_TREE;
1529
1530         char *mo_full_path = NULL;
1531         sync_agent_dm_mo_node_s *root_node = NULL;
1532         int count = 0;
1533         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1534
1535         err = sync_agent_get_descendant_mo_tree(mo_type, mo_full_path, &root_node, &count, SYNC_AGENT_DM_MO_GET_OPTION_NODE);
1536         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1537                 dts_message(api_name, "sync_agent_framework : %d", err);
1538
1539                 dts_fail(api_name);
1540         } else {
1541
1542                 dts_pass(api_name);
1543         }
1544
1545 }
1546
1547 static void *print_Node(sync_agent_dm_mo_node_s * mo_node, int depth, void **data)
1548 {
1549         _EXTERN_FUNC_ENTER;
1550
1551         _EXTERN_FUNC_EXIT;
1552         return 0;
1553 }
1554
1555 static void utc_sync_agent_framework_sync_agent_traverse_mo_tree_preorder_p(void)
1556 {
1557         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1558         char *api_name = API_NAME_SYNC_AGENT_TRAVERSE_MO_TREE_PREORDER;
1559
1560         char *mo_full_path = NULL;
1561         sync_agent_dm_mo_node_s sync_agent_mo_item;
1562         sync_agent_dm_mo_node_s *root_node = NULL;
1563         int v_err = 0;
1564         int count = 0;
1565         int depth = 1;
1566         void *arg = NULL;
1567
1568         sync_agent_mo_item.mo_type = 0;
1569         sync_agent_mo_item.full_path = "./dmacc/test11";
1570         sync_agent_mo_item.value = "aa";
1571         sync_agent_mo_item.type = SYNC_AGENT_DM_MO_NODE_LEAF;
1572
1573         err = sync_agent_add_mo_item(&sync_agent_mo_item);
1574         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1575                 dts_message(api_name, "sync_agent_framework : %d", err);
1576                 dts_fail(api_name);
1577         }
1578
1579         mo_full_path = "./dmacc";
1580
1581         err = sync_agent_get_descendant_mo_tree(0, mo_full_path, &root_node, &count, SYNC_AGENT_DM_MO_GET_OPTION_NODE);
1582         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1583                 dts_message(api_name, "sync_agent_framework : %d", err);
1584                 dts_fail(api_name);
1585         }
1586
1587         v_err = sync_agent_traverse_mo_tree_preorder(root_node, print_Node, depth, 0, &arg);
1588         if (v_err != 0) {
1589                 dts_message(api_name, "sync_agent_framework : %d", err);
1590                 dts_fail(api_name);
1591         } else {
1592                 dts_pass(api_name);
1593         }
1594
1595 }
1596
1597 static void utc_sync_agent_framework_sync_agent_traverse_mo_tree_preorder_n(void)
1598 {
1599         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1600         char *api_name = API_NAME_SYNC_AGENT_TRAVERSE_MO_TREE_PREORDER;
1601         char *mo_full_path = NULL;
1602         sync_agent_dm_mo_type_e mo_type = 0;
1603         sync_agent_dm_mo_node_s sync_agent_mo_item;
1604         sync_agent_dm_mo_node_s *root_node = NULL;
1605         int v_err = NULL;
1606         int count = 0;
1607         int depth = 0;
1608         void *arg = NULL;
1609
1610         v_err = sync_agent_traverse_mo_tree_preorder(root_node, NULL, depth, 0, &arg);
1611         if (v_err == 0) {
1612                 dts_message(api_name, "sync_agent_framework : %d", err);
1613                 dts_fail(api_name);
1614         } else {
1615                 dts_pass(api_name);
1616         }
1617 }
1618
1619 static void utc_sync_agent_framework_sync_agent_export_tnds_stream_p(void)
1620 {
1621         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1622         char *api_name = API_NAME_SYNC_AGENT_EXPORT_TNDS_STREAM;
1623
1624         char *mo_path = NULL;
1625         char *output_stream = NULL;
1626         unsigned int byte_size = 0;
1627         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1628         const char *vendar_file = "/usr/share/oma-dm-cfg/ddf/slp/slp_gcf_dmacc_ddf_1.2.xml";
1629         int mo_plugin_id = 4;
1630         int server_type = 16;
1631
1632         err = sync_agent_construct_mo_table(mo_type, vendar_file, mo_plugin_id, server_type);
1633         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1634                 dts_message(api_name, "sync_agent_framework : %d", err);
1635                 dts_fail(api_name);
1636         }
1637
1638         mo_path = "./DMAcc";
1639
1640         err = sync_agent_export_tnds_stream(SYNC_AGENT_DM_MO_TNDS_TYPE_WBXML, mo_type, mo_path, &output_stream, &byte_size);
1641         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1642                 dts_message(api_name, "sync_agent_framework : %d", err);
1643
1644                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1645                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1646                         dts_message(api_name, "sync_agent_framework : %d", err);
1647                         dts_fail(api_name);
1648                 }
1649
1650                 dts_fail(api_name);
1651         } else {
1652
1653                 err = sync_agent_delete_mo_tree_item("./DMAcc");
1654                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1655                         dts_message(api_name, "sync_agent_framework : %d", err);
1656                         dts_fail(api_name);
1657                 }
1658
1659                 dts_pass(api_name);
1660         }
1661
1662 }
1663
1664 static void utc_sync_agent_framework_sync_agent_export_tnds_stream_n(void)
1665 {
1666         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1667         char *api_name = API_NAME_SYNC_AGENT_EXPORT_TNDS_STREAM;
1668
1669         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1670         char *mo_path = NULL;
1671         char *output_stream = NULL;
1672         unsigned int byte_size = 0;
1673
1674         err = sync_agent_export_tnds_stream(SYNC_AGENT_DM_MO_TNDS_TYPE_WBXML, mo_type, mo_path, &output_stream, &byte_size);
1675         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1676                 dts_message(api_name, "sync_agent_framework : %d", err);
1677
1678                 dts_fail(api_name);
1679         } else {
1680
1681                 dts_pass(api_name);
1682         }
1683
1684 }
1685
1686 static void utc_sync_agent_framework_sync_agent_import_tnds_stream_p(void)
1687 {
1688         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1689         char *api_name = API_NAME_SYNC_AGENT_EXPORT_TNDS_STREAM;
1690
1691         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1692         char *mo_path = NULL;
1693         char *input_stream = NULL;
1694         unsigned int byte_size = 0;
1695
1696         sync_agent_fsapi_return_e f_err = SYNC_AGENT_FSAPI_TRUE;
1697
1698         f_err = sync_agent_is_existing_fs(TNDS_SAMPLE_FILE);
1699         if (f_err != SYNC_AGENT_FSAPI_TRUE) {
1700                 dts_message(api_name, "sync_agent_framework : %d", err);
1701                 dts_fail(api_name);
1702         }
1703
1704         f_err = sync_agent_read_whole_file(TNDS_SAMPLE_FILE, &input_stream, &byte_size);
1705         if (f_err != SYNC_AGENT_FSAPI_TRUE) {
1706                 dts_message(api_name, "sync_agent_framework : %d", err);
1707                 dts_fail(api_name);
1708         }
1709
1710         mo_path = "./test";
1711
1712         err = sync_agent_import_tnds_stream(SYNC_AGENT_DM_MO_TNDS_ACTION_ADD, SYNC_AGENT_DM_MO_TNDS_TYPE_XML, mo_type, mo_path, input_stream, byte_size);
1713         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1714                 dts_message(api_name, "sync_agent_framework : %d", err);
1715
1716                 err = sync_agent_delete_mo_tree_item("./test");
1717                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1718                         dts_message(api_name, "sync_agent_framework : %d", err);
1719                         dts_fail(api_name);
1720                 }
1721
1722                 dts_fail(api_name);
1723         } else {
1724
1725                 err = sync_agent_delete_mo_tree_item("./test");
1726                 if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1727                         dts_message(api_name, "sync_agent_framework : %d", err);
1728                         dts_fail(api_name);
1729                 }
1730
1731                 dts_pass(api_name);
1732         }
1733 }
1734
1735 static void utc_sync_agent_framework_sync_agent_import_tnds_stream_n(void)
1736 {
1737         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1738         char *api_name = API_NAME_SYNC_AGENT_EXPORT_TNDS_STREAM;
1739         sync_agent_dm_mo_type_e mo_type = SYNC_AGENT_DM_MO_TYPE_DMACC;
1740         char *mo_path = NULL;
1741         char *input_stream = NULL;
1742         unsigned int byte_size = 0;
1743
1744         mo_path = NULL;
1745
1746         err = sync_agent_import_tnds_stream(SYNC_AGENT_DM_MO_TNDS_ACTION_ADD, SYNC_AGENT_DM_MO_TNDS_TYPE_XML, mo_type, mo_path, input_stream, byte_size);
1747         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1748                 dts_message(api_name, "sync_agent_framework : %d", err);
1749                 dts_fail(api_name);
1750         } else {
1751                 dts_pass(api_name);
1752         }
1753 }
1754
1755 static void utc_sync_agent_framework_sync_agent_open_p(void)
1756 {
1757         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1758         char *api_name = API_NAME_SYNC_AGENT_OPEN;
1759
1760         err = sync_agent_open_mo();
1761         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1762                 dts_message(api_name, "sync_agent_framework : %d", err);
1763                 dts_fail(api_name);
1764         } else {
1765                 dts_pass(api_name);
1766         }
1767
1768 }
1769
1770 static void utc_sync_agent_framework_sync_agent_close_p(void)
1771 {
1772         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1773         char *api_name = API_NAME_SYNC_AGENT_CLOSE;
1774
1775         err = sync_agent_close_mo();
1776         if (err != SYNC_AGENT_DM_MO_SUCCESS) {
1777                 dts_message(api_name, "sync_agent_framework : %d", err);
1778                 dts_fail(api_name);
1779         } else {
1780                 dts_pass(api_name);
1781         }
1782 }
1783
1784 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1785
1786 static void utc_sync_agent_framework_sync_agent_execute_mo_ext_n(void)
1787 {
1788         sync_agent_dm_mo_error_e err = SYNC_AGENT_DM_MO_SUCCESS;
1789         char *api_name = API_NAME_SYNC_AGENT_EXECUTE_MO_EXT;
1790         const char *mo_path = NULL;
1791         int err_num = 0;
1792         int check_operation = 1;
1793
1794         err = sync_agent_execute_mo_ext(mo_path, &err_num, check_operation);
1795         if (err == SYNC_AGENT_DM_MO_SUCCESS) {
1796                 dts_message(api_name, "sync_agent_framework : %d", err);
1797
1798                 dts_fail(api_name);
1799         } else {
1800                 dts_pass(api_name);
1801         }
1802
1803 }
1804
1805 static void utc_sync_agent_framework_sync_agent_start_mdm_service_p(void)
1806 {
1807
1808         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1809         char *api_name = API_NAME_SYNC_AGENT_START_MDM_SERVICE;
1810
1811         err = sync_agent_start_mdm_service(1, "syncagent-service");
1812         if (err != SYNC_AGENT_DM_MDM_SUCCEEDED) {
1813                 dts_message(api_name, "sync_agent_framework : %d", err);
1814
1815                 dts_fail(api_name);
1816         } else {
1817                 dts_pass(api_name);
1818         }
1819
1820 }
1821
1822 static void utc_sync_agent_framework_sync_agent_start_mdm_service_n(void)
1823 {
1824         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1825         char *api_name = API_NAME_SYNC_AGENT_START_MDM_SERVICE;
1826
1827         err = sync_agent_start_mdm_service(1, NULL);
1828         if (err == SYNC_AGENT_DM_MDM_SUCCEEDED) {
1829                 dts_message(api_name, "sync_agent_framework : %d", err);
1830
1831                 dts_fail(api_name);
1832         } else {
1833                 dts_pass(api_name);
1834         }
1835 }
1836
1837 static void utc_sync_agent_framework_sync_agent_stop_mdm_service_p(void)
1838 {
1839
1840         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1841         char *api_name = API_NAME_SYNC_AGENT_STOP_MDM_SERVICE;
1842
1843         err = sync_agent_stop_mdm_service(1, "syncagent-service");
1844         if (err != SYNC_AGENT_DM_MDM_SUCCEEDED) {
1845                 dts_message(api_name, "sync_agent_framework : %d", err);
1846
1847                 dts_fail(api_name);
1848         } else {
1849                 dts_pass(api_name);
1850         }
1851
1852 }
1853
1854 static void utc_sync_agent_framework_sync_agent_stop_mdm_service_n(void)
1855 {
1856         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1857         char *api_name = API_NAME_SYNC_AGENT_STOP_MDM_SERVICE;
1858
1859         err = sync_agent_stop_mdm_service(1, NULL);
1860         if (err == SYNC_AGENT_DM_MDM_SUCCEEDED) {
1861                 dts_message(api_name, "sync_agent_framework : %d", err);
1862
1863                 dts_fail(api_name);
1864         } else {
1865                 dts_pass(api_name);
1866         }
1867 }
1868
1869 static void utc_sync_agent_framework_sync_agent_set_mdm_value_p(void)
1870 {
1871         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1872         char *api_name = API_NAME_SYNC_AGENT_GET_MDM_SERVICE;
1873
1874         err = sync_agent_set_mdm_value(1, SYNC_AGENT_DM_MDM_ALLOW_WIFI, SYNC_AGENT_DM_MDM_ALLOWED);
1875         if (err != SYNC_AGENT_DM_MDM_SUCCEEDED) {
1876                 dts_message(api_name, "sync_agent_framework : %d", err);
1877
1878                 dts_fail(api_name);
1879         } else {
1880                 dts_pass(api_name);
1881         }
1882
1883 }
1884
1885 static void utc_sync_agent_framework_sync_agent_set_mdm_value_n(void)
1886 {
1887         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1888         char *api_name = API_NAME_SYNC_AGENT_GET_MDM_SERVICE;
1889
1890         err = sync_agent_set_mdm_value(1, 102, 3);
1891         if (err == SYNC_AGENT_DM_MDM_SUCCEEDED) {
1892                 dts_message(api_name, "sync_agent_framework : %d", err);
1893
1894                 dts_fail(api_name);
1895         } else {
1896                 dts_pass(api_name);
1897         }
1898 }
1899
1900 static void utc_sync_agent_framework_sync_agent_get_mdm_value_p(void)
1901 {
1902         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1903         char *api_name = API_NAME_SYNC_AGENT_SET_MDM_SERVICE;
1904
1905         sync_agent_dm_mdm_password_policy_s old_policy = { 0 };
1906
1907         err = sync_agent_get_mdm_value(1, SYNC_AGENT_DM_MDM_PWD_POLICY, &old_policy);
1908         if (err != SYNC_AGENT_DM_MDM_SUCCEEDED) {
1909                 dts_message(api_name, "sync_agent_framework : %d", err);
1910
1911                 dts_fail(api_name);
1912         } else {
1913                 dts_pass(api_name);
1914         }
1915
1916 }
1917
1918 static void utc_sync_agent_framework_sync_agent_get_mdm_value_n(void)
1919 {
1920         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1921         char *api_name = API_NAME_SYNC_AGENT_SET_MDM_SERVICE;
1922
1923         sync_agent_dm_mdm_password_policy_s old_policy = { 0 };
1924
1925         err = sync_agent_get_mdm_value(1, 102, &old_policy);
1926         if (err == SYNC_AGENT_DM_MDM_SUCCEEDED) {
1927                 dts_message(api_name, "sync_agent_framework : %d", err);
1928
1929                 dts_fail(api_name);
1930         } else {
1931                 dts_pass(api_name);
1932         }
1933
1934 }
1935
1936 static void utc_sync_agent_framework_sync_agent_execute_mdm_p(void)
1937 {
1938         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1939         char *api_name = API_NAME_SYNC_AGENT_EXECUTE_MDM_SERVICE;
1940
1941         err = sync_agent_execute_mdm(1, SYNC_AGENT_DM_MDM_EXE_ENFORCE_PWD_CHANGE);
1942         if (err != SYNC_AGENT_DM_MDM_SUCCEEDED) {
1943                 dts_message(api_name, "sync_agent_framework : %d", err);
1944
1945                 dts_fail(api_name);
1946         } else {
1947                 dts_pass(api_name);
1948         }
1949
1950 }
1951
1952 static void utc_sync_agent_framework_sync_agent_execute_mdm_n(void)
1953 {
1954         sync_agent_dm_mdm_return_e err = SYNC_AGENT_DM_MDM_SUCCEEDED;
1955         char *api_name = API_NAME_SYNC_AGENT_EXECUTE_MDM_SERVICE;
1956
1957         err = sync_agent_execute_mdm(1, 102);
1958         if (err == SYNC_AGENT_DM_MDM_SUCCEEDED) {
1959                 dts_message(api_name, "sync_agent_framework : %d", err);
1960
1961                 dts_fail(api_name);
1962         } else {
1963                 dts_pass(api_name);
1964         }
1965
1966 }