wearable/TC/testcase/utc_ss.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <tet_api.h>
  22 #include <stdlib.h>
  23
  24 #include <tapi_common.h>
  25 #include <ITapiSs.h>
  26 #include <TapiUtility.h>
  27
  28 #include "util_common.h"
  29
  30 TapiHandle *handle;
  31 enum async_state async_flag;
  32
  33 static char data_ss_set_barring_password[TAPI_SS_GSM_BARR_PW_LEN_MAX+1] = "0000";
  34
  35 TelSsClass_t  class = 0x10;
  36
  37 TelSsBarringType_t barring_type[9] = {
  38         TAPI_SS_CB_TYPE_BAOC,
  39         TAPI_SS_CB_TYPE_BOIC,
  40         TAPI_SS_CB_TYPE_BOIC_NOT_HC,
  41         TAPI_SS_CB_TYPE_BAIC,
  42         TAPI_SS_CB_TYPE_BIC_ROAM,
  43         TAPI_SS_CB_TYPE_AB,
  44         TAPI_SS_CB_TYPE_AOB,
  45         TAPI_SS_CB_TYPE_AIB,
  46         TAPI_SS_CB_TYPE_BIC_NOT_SIM
  47 } ;
  48
  49 TelSsBarringMode_t barring_mode [2] = {
  50         TAPI_SS_CB_MODE_ACTIVATE,
  51         TAPI_SS_CB_MODE_DEACTIVATE
  52 };
  53
  54 TelSsForwardWhen_t forwarding_type[7] = {
  55         TAPI_SS_CF_WHEN_CFU,
  56         TAPI_SS_CF_WHEN_CFB,
  57         TAPI_SS_CF_WHEN_CFNRy,
  58         TAPI_SS_CF_WHEN_CFNRc,
  59         TAPI_SS_CF_WHEN_CF_ALL,
  60         TAPI_SS_CF_WHEN_CFC
  61 };
  62
  63 TelSsForwardMode_t forwarding_mode[4] = {
  64         TAPI_SS_CF_MODE_DISABLE_EV,
  65         TAPI_SS_CF_MODE_ENABLE_EV,
  66         TAPI_SS_CF_MODE_REGISTRATION_EV,
  67         TAPI_SS_CF_MODE_ERASURE_EV
  68 };
  69
  70 TelSsCallWaitingMode_t waiting_mode [2] = {
  71         TAPI_SS_CW_MODE_ACTIVATE,
  72         TAPI_SS_CW_MODE_DEACTIVATE
  73 };
  74
  75 TelSsCliType_t cli_type[6] = {
  76         TAPI_SS_CLI_CLIP,
  77         TAPI_SS_CLI_CLIR,
  78         TAPI_SS_CLI_COLP,
  79         TAPI_SS_CLI_COLR,
  80         TAPI_SS_CLI_CDIP,
  81         TAPI_SS_CLI_CNAP
  82 };
  83
  84 TelSsCliStatus_t cli_mode[6] = {
  85         TAPI_CLI_STATUS_NOT_PROVISONED,
  86         TAPI_CLI_STATUS_PROVISIONED,
  87         TAPI_CLI_STATUS_ACTIVATED,
  88         TAPI_CLI_STATUS_UNKOWN,
  89         TAPI_CLI_STATUS_TEMP_RESTRICTED,
  90         TAPI_CLI_STATUS_TEMP_ALLOWED
  91 };
  92
  93 /* Barring Activate/De-activate Macro */
  94 #define DO_BARRING(func, param1, param2, param3) \
  95         static void on_##func(TapiHandle *handle, int result, void *data, void *user_data) \
  96         { \
  97                 int *value = user_data; \
  98 \
  99                 async_flag = ASYNC_DONE; \
 100                 util_stop_loop(); \
 101 \
 102                 if (*value != 0xC0FFEE) { \
 103                         dts_fail(#func, "Callback userdata crashed"); \
 104                 } \
 105                 if (result != 0x0) { \
 106                         dts_fail(#func, "Operation failed"); \
 107                 } \
 108         } \
 109 \
 110         static void utc_##func (TelSsClass_t  param1, TelSsBarringType_t param2, TelSsBarringMode_t param3) \
 111         { \
 112                 TelSsBarringInfo_t info; \
 113                 int ret; \
 114                 int value = 0xC0FFEE; \
 115 \
 116                 /* with callback */ \
 117                 util_init_loop(); \
 118 \
 119                 async_flag = ASYNC_READY; \
 120                 memset(&info, 0, sizeof(TelSsBarringInfo_t)); \
 121                 info.Class =param1; \
 122                 info.Type = param2; \
 123                 info.Mode = param3; \
 124                 g_strlcpy(info.szPassword, data_ss_set_barring_password, TAPI_SS_GSM_BARR_PW_LEN_MAX); \
 125                 ret = tel_set_ss_barring (handle, &info, on_##func, &value); \
 126                 if (ret != TAPI_API_SUCCESS) { \
 127                         dts_fail(#func, "Unexpected return"); \
 128                 } \
 129 \
 130                 util_start_loop(); \
 131                 util_free_loop(); \
 132 \
 133                 if (async_flag != ASYNC_DONE) { \
 134                         dts_fail(#func, "Callback not invoked"); \
 135                 } \
 136 \
 137                 dts_pass(#func); \
 138         } \
 139 \
 140         static void utc_fail_##func (TelSsClass_t  param1, TelSsBarringType_t param2, TelSsBarringMode_t param3) \
 141         { \
 142                 int ret; \
 143 \
 144                 ret = tel_set_ss_barring (NULL, NULL, NULL,NULL); \
 145                 dts_check_ne(#func, ret, TAPI_API_SUCCESS, "Unexpected return"); \
 146         }
 147
 148 /* Barring Status Macro */
 149 #define DO_BARRING_STATUS(func, param1, param2) \
 150         static void on_##func (TapiHandle *handle, int result, void *data, void *user_data) \
 151         { \
 152                 int *value = user_data; \
 153 \
 154                 async_flag = ASYNC_DONE; \
 155                 util_stop_loop(); \
 156 \
 157                 if (*value != 0xC0FFEE) { \
 158                         dts_fail(#func, "Callback userdata crashed"); \
 159                 } \
 160                 if (result != 0x0) { \
 161                         dts_fail(#func, "Operation failed"); \
 162                 } \
 163         } \
 164 \
 165         static void utc_##func (TelSsClass_t  param1, TelSsBarringType_t param2) \
 166         { \
 167                 int ret; \
 168                 int value = 0xC0FFEE; \
 169 \
 170                 /* with callback */ \
 171                 util_init_loop(); \
 172 \
 173                 async_flag = ASYNC_READY; \
 174                 ret = tel_get_ss_barring_status (handle, param1, param2, on_##func, &value); \
 175                 if (ret != TAPI_API_SUCCESS) { \
 176                         dts_fail(#func, "Unexpected return"); \
 177                 } \
 178 \
 179                 util_start_loop(); \
 180                 util_free_loop(); \
 181 \
 182                 if (async_flag != ASYNC_DONE) { \
 183                         dts_fail(#func, "Callback not invoked"); \
 184                 } \
 185 \
 186                 dts_pass(#func); \
 187         } \
 188 \
 189         static void utc_fail_##func (TelSsClass_t  param1, TelSsBarringType_t param2) \
 190         { \
 191                 int ret; \
 192 \
 193                 ret = tel_get_ss_barring_status (NULL, 0, 0, NULL, NULL); \
 194                 dts_check_ne(#func, ret, TAPI_API_SUCCESS, "Unexpected return"); \
 195         }
 196
 197 /* Forwarding Register/Erasure Macro*/
 198 #define DO_FORWARDING(func, param1, param2, param3) \
 199         static void on_##func (TapiHandle *handle, int result, void *data, void *user_data) \
 200         { \
 201                 int *value = user_data; \
 202 \
 203                 async_flag = ASYNC_DONE; \
 204                 util_stop_loop(); \
 205 \
 206                 if (*value != 0xC0FFEE) { \
 207                         dts_fail(#func, "Callback userdata crashed"); \
 208                 } \
 209                 if (result != 0x0) { \
 210                         dts_fail(#func, "Operation failed"); \
 211                 } \
 212         } \
 213 \
 214         static void utc_##func (TelSsClass_t  param1, TelSsForwardWhen_t param2, TelSsForwardMode_t param3) \
 215         { \
 216                 TelSsForwardInfo_t info;\
 217                 int ret; \
 218                 int value = 0xC0FFEE; \
 219 \
 220                 /* with callback */ \
 221                 util_init_loop(); \
 222 \
 223                 async_flag = ASYNC_READY; \
 224                 memset(&info, 0, sizeof(TelSsForwardInfo_t)); \
 225                 info.Class = param1; \
 226                 info.Condition = param2; \
 227                 info.NoReplyConditionTimer = 0x05;\
 228                 info.Mode = param3;\
 229                 info.Ton = 0x01;\
 230                 info.Npi = 0x01;\
 231                 strncpy((char*)info.szPhoneNumber, "+919535099681", 13);\
 232                 info.szPhoneNumber[13] = '\0';\
 233                 ret = tel_set_ss_forward (handle, &info, on_##func, &value); \
 234                 if (ret != TAPI_API_SUCCESS) { \
 235                         dts_fail(#func, "Unexpected return"); \
 236                 } \
 237 \
 238                 util_start_loop(); \
 239                 util_free_loop(); \
 240 \
 241                 if (async_flag != ASYNC_DONE) { \
 242                         dts_fail(#func, "Callback not invoked"); \
 243                 } \
 244 \
 245                 dts_pass(#func); \
 246         } \
 247 \
 248         static void utc_fail_##func (TelSsClass_t  param1, TelSsForwardWhen_t param2, TelSsForwardMode_t param3) \
 249         { \
 250                 int ret; \
 251 \
 252                 ret = tel_set_ss_forward (NULL, NULL, NULL, NULL); \
 253                 dts_check_ne(#func, ret, TAPI_API_SUCCESS, "Unexpected return"); \
 254         }
 255
 256 /* Forwarding Get Status Macro*/
 257 #define DO_FORWARDING_STATUS(func, param1, param2) \
 258         static void on_##func (TapiHandle *handle, int result, void *data, void *user_data) \
 259         { \
 260                 int *value = user_data; \
 261 \
 262                 async_flag = ASYNC_DONE; \
 263                 util_stop_loop(); \
 264 \
 265                 if (*value != 0xC0FFEE) { \
 266                         dts_fail(#func, "Callback userdata crashed"); \
 267                 } \
 268                 if (result != 0x0) { \
 269                         dts_fail(#func, "Operation failed"); \
 270                 } \
 271         } \
 272 \
 273         static void utc_##func (TelSsClass_t  param1, TelSsForwardWhen_t param2) \
 274         { \
 275                 int ret; \
 276                 int value = 0xC0FFEE; \
 277 \
 278                 /* with callback */ \
 279                 util_init_loop(); \
 280 \
 281                 async_flag = ASYNC_READY; \
 282                 ret = tel_get_ss_forward_status (handle, param1, param2, on_##func, &value); \
 283                 if (ret != TAPI_API_SUCCESS) { \
 284                         dts_fail(#func, "Unexpected return"); \
 285                 } \
 286 \
 287                 util_start_loop(); \
 288                 util_free_loop(); \
 289 \
 290                 if (async_flag != ASYNC_DONE) { \
 291                         dts_fail(#func, "Callback not invoked"); \
 292                 } \
 293 \
 294                 dts_pass(#func); \
 295         } \
 296 \
 297         static void utc_fail_##func (TelSsClass_t  param1, TelSsForwardWhen_t param2) \
 298         { \
 299                 int ret; \
 300 \
 301                 ret = tel_get_ss_forward_status (NULL, 0, 0, NULL, NULL); \
 302                 dts_check_ne(#func, ret, TAPI_API_SUCCESS, "Unexpected return"); \
 303         }
 304
 305 /* Waiting Activate/De-activate Macro*/
 306 #define DO_WAITING(func, param1, param2) \
 307         static void on_##func (TapiHandle *handle, int result, void *data, void *user_data) \
 308         { \
 309                 int *value = user_data; \
 310 \
 311                 async_flag = ASYNC_DONE; \
 312                 util_stop_loop(); \
 313 \
 314                 if (*value != 0xC0FFEE) { \
 315                         dts_fail(#func, "Callback userdata crashed"); \
 316                 } \
 317                 if (result != 0x0) { \
 318                         dts_fail(#func, "Operation failed"); \
 319                 } \
 320         } \
 321 \
 322         static void utc_##func (TelSsClass_t param1, TelSsCallWaitingMode_t param2) \
 323         { \
 324                 TelSsWaitingInfo_t info; \
 325                 int ret; \
 326                 int value = 0xC0FFEE; \
 327 \
 328                 /* with callback */ \
 329                 util_init_loop(); \
 330                 memset(&info, 0, sizeof(TelSsWaitingInfo_t)); \
 331                 async_flag = ASYNC_READY; \
 332                 info.Class = param1;\
 333                 info.Mode = param2;\
 334                 ret = tel_set_ss_waiting (handle, &info, on_##func, &value); \
 335                 if (ret != TAPI_API_SUCCESS) { \
 336                         dts_fail(#func, "Unexpected return"); \
 337                 } \
 338 \
 339                 util_start_loop(); \
 340                 util_free_loop(); \
 341 \
 342                 if (async_flag != ASYNC_DONE) { \
 343                         dts_fail(#func, "Callback not invoked"); \
 344                 } \
 345 \
 346                 dts_pass(#func); \
 347         } \
 348 \
 349         static void utc_fail_##func (TelSsClass_t param1, TelSsCallWaitingMode_t param2) \
 350         { \
 351                 int ret; \
 352 \
 353                 ret = tel_set_ss_waiting (NULL, NULL, NULL, NULL); \
 354                 dts_check_ne(#func, ret, TAPI_API_SUCCESS, "Unexpected return"); \
 355         }
 356
 357 /* Set CLI Status Macro */
 358 #define DO_CLI(func, param1, param2) \
 359         static void on_##func (TapiHandle *handle, int result, void *data, void *user_data) \
 360         { \
 361                 int *value = user_data; \
 362 \
 363                 async_flag = ASYNC_DONE; \
 364                 util_stop_loop(); \
 365 \
 366                 if (*value != 0xC0FFEE) { \
 367                         dts_fail(#func, "Callback userdata crashed"); \
 368                 } \
 369                 if (result != 0x0) { \
 370                         dts_fail(#func, "Operation failed"); \
 371                 } \
 372         } \
 373 \
 374         static void utc_##func (TelSsCliType_t param1, TelSsCliStatus_t param2) \
 375         { \
 376                 int ret; \
 377                 int value = 0xC0FFEE; \
 378 \
 379                 /* with callback */ \
 380                 util_init_loop(); \
 381 \
 382                 async_flag = ASYNC_READY; \
 383                 ret = tel_set_ss_cli_status(handle, param1, param2, on_##func, &value); \
 384                 if (ret != TAPI_API_SUCCESS) { \
 385                         dts_fail(#func, "Unexpected return"); \
 386                 } \
 387 \
 388                 util_start_loop(); \
 389                 util_free_loop(); \
 390 \
 391                 if (async_flag != ASYNC_DONE) { \
 392                         dts_fail(#func, "Callback not invoked"); \
 393                 } \
 394 \
 395                 dts_pass(#func); \
 396         } \
 397 \
 398         static void utc_fail_##func (TelSsCliType_t param1) \
 399         { \
 400                 int ret; \
 401 \
 402                 ret = tel_set_ss_cli_status (NULL, 0, 0, NULL, NULL); \
 403                 dts_check_ne(#func, ret, TAPI_API_SUCCESS, "Unexpected return"); \
 404         }
 405
 406 /* CLI Interrogation Macro */
 407 #define DO_CLI_STATUS(func, param1) \
 408         static void on_##func (TapiHandle *handle, int result, void *data, void *user_data) \
 409         { \
 410                 int *value = user_data; \
 411 \
 412                 async_flag = ASYNC_DONE; \
 413                 util_stop_loop(); \
 414 \
 415                 if (*value != 0xC0FFEE) { \
 416                         dts_fail(#func, "Callback userdata crashed"); \
 417                 } \
 418                 if (result != 0x0) { \
 419                         dts_fail(#func, "Operation failed"); \
 420                 } \
 421         } \
 422 \
 423         static void utc_##func (TelSsCliType_t param1) \
 424         { \
 425                 int ret; \
 426                 int value = 0xC0FFEE; \
 427 \
 428                 /* with callback */ \
 429                 util_init_loop(); \
 430 \
 431                 async_flag = ASYNC_READY; \
 432                 ret = tel_get_ss_cli_status(handle, param1, on_##func, &value); \
 433                 if (ret != TAPI_API_SUCCESS) { \
 434                         dts_fail(#func, "Unexpected return"); \
 435                 } \
 436 \
 437                 util_start_loop(); \
 438                 util_free_loop(); \
 439 \
 440                 if (async_flag != ASYNC_DONE) { \
 441                         dts_fail(#func, "Callback not invoked"); \
 442                 } \
 443 \
 444                 dts_pass(#func); \
 445         } \
 446 \
 447         static void utc_fail_##func (TelSsCliType_t param1) \
 448         { \
 449                 int ret; \
 450 \
 451                 ret = tel_get_ss_cli_status (NULL, 0, NULL, NULL); \
 452                 dts_check_ne(#func, ret, TAPI_API_SUCCESS, "Unexpected return"); \
 453         }
 454
 455
 456 /**
 457  * tel_change_ss_barring_password
 458  *
 459  */
 460 static void on_tel_change_ss_barring_password (TapiHandle *handle, int result, void *data, void *user_data)
 461 {
 462         int *value = user_data;
 463
 464         async_flag = ASYNC_DONE;
 465         util_stop_loop ();
 466
 467         if (*value != 0xC0FFEE) {
 468                 dts_fail("tel_change_ss_barring_password", "Callback userdata crashed");
 469         }
 470         if (result != 0x0) {
 471                 dts_fail("tel_change_ss_barring_password", "Operation failed");
 472         }
 473 }
 474
 475 static void utc_tel_change_ss_barring_password (void)
 476 {
 477         int ret;
 478         int value = 0xC0FFEE;
 479
 480         util_init_loop ();
 481
 482         async_flag = ASYNC_READY;
 483         ret = tel_change_ss_barring_password (handle, "0000","1111", "1111",
 484                         on_tel_change_ss_barring_password, &value);
 485         if (ret != TAPI_API_SUCCESS) {
 486                 dts_fail("tel_change_ss_barring_password", "Unexpected return");
 487         }
 488
 489         util_start_loop ();
 490         util_free_loop ();
 491
 492         if (async_flag != ASYNC_DONE) {
 493                 dts_fail("tel_change_ss_barring_password", "Callback not invoked");
 494         }
 495
 496         dts_pass("tel_change_ss_barring_password");
 497 }
 498
 499 static void utc_fail_tel_change_ss_barring_password (void)
 500 {
 501         int ret;
 502
 503         ret = tel_change_ss_barring_password (NULL, NULL, 0, NULL, NULL, NULL);
 504         if (ret == TAPI_API_SUCCESS) {
 505                 dts_fail("tel_change_ss_barring_password", "Parameter check failed");
 506         }
 507
 508         ret = tel_change_ss_barring_password (handle, NULL, 0, NULL, NULL, NULL);
 509         if (ret == TAPI_API_SUCCESS) {
 510                 dts_fail("tel_change_ss_barring_password", "Parameter check failed");
 511         }
 512
 513         dts_pass("tel_change_ss_barring_password");
 514 }
 515
 516
 517 /**
 518  * tel_ss_waiting_status
 519  *
 520  */
 521 static void on_tel_ss_waiting_status (TapiHandle *handle, int result, void *data, void *user_data)
 522 {
 523         int *value = user_data;
 524
 525         async_flag = ASYNC_DONE;
 526         util_stop_loop ();
 527
 528         if (*value != 0xC0FFEE) {
 529                 dts_fail("tel_ss_waiting_status", "Callback userdata crashed");
 530         }
 531         if (result != 0x0) {
 532                 dts_fail("tel_ss_waiting_status", "Operation failed");
 533         }
 534 }
 535
 536 static void utc_tel_ss_waiting_status (void)
 537 {
 538         int ret;
 539         int value = 0xC0FFEE;
 540
 541         util_init_loop ();
 542
 543         async_flag = ASYNC_READY;
 544         ret = tel_get_ss_waiting_status (handle, 0x10,
 545                         on_tel_ss_waiting_status, &value);
 546         if (ret != TAPI_API_SUCCESS) {
 547                 dts_fail("tel_ss_waiting_status", "Unexpected return");
 548         }
 549
 550         util_start_loop ();
 551         util_free_loop ();
 552
 553         if (async_flag != ASYNC_DONE) {
 554                 dts_fail("tel_ss_waiting_status", "Callback not invoked");
 555         }
 556
 557         dts_pass("tel_ss_waiting_status");
 558 }
 559
 560 static void utc_fail_tel_ss_waiting_status (void)
 561 {
 562         int ret;
 563
 564         ret = tel_get_ss_waiting_status (NULL, 0, NULL, NULL);
 565         if (ret == TAPI_API_SUCCESS) {
 566                 dts_fail("el_ss_waiting_status", "Parameter check failed");
 567         }
 568
 569         ret = tel_get_ss_waiting_status (handle, 0, NULL, NULL);
 570         if (ret == TAPI_API_SUCCESS) {
 571                 dts_fail("el_ss_waiting_status", "Parameter check failed");
 572         }
 573
 574         dts_pass("el_ss_waiting_status");
 575 }
 576
 577
 578 /**
 579  * tel_ss_init_ussd
 580  *
 581  */
 582 static void on_tel_ss_init_ussd (TapiHandle *handle, int result, void *data, void *user_data)
 583 {
 584         int *value = user_data;
 585
 586         async_flag = ASYNC_DONE;
 587         util_stop_loop ();
 588
 589         if (*value != 0xC0FFEE) {
 590                 dts_fail("tel_ss_init_ussd", "Callback userdata crashed");
 591         }
 592         if (result != 0x0) {
 593                 dts_fail("tel_ss_init_ussd", "Operation failed");
 594         }
 595 }
 596
 597 static void utc_tel_ss_init_ussd (void)
 598 {
 599         int ret;
 600         int value = 0xC0FFEE;
 601         TelSsUssdMsgInfo_t info;
 602
 603         util_init_loop ();
 604
 605         async_flag = ASYNC_READY;
 606         memset(&info, 0, sizeof(TelSsUssdMsgInfo_t));
 607         info.Type = 0x01;
 608         info.Length = 0x05;
 609         strncpy(info.szString, "*121#", 5);
 610         ret = tel_send_ss_ussd_request (handle, &info,
 611                         on_tel_ss_init_ussd, &value);
 612         if (ret != TAPI_API_SUCCESS) {
 613                 dts_fail("tel_ss_init_ussd", "Unexpected return");
 614         }
 615
 616         util_start_loop ();
 617         util_free_loop ();
 618
 619         if (async_flag != ASYNC_DONE) {
 620                 dts_fail("tel_ss_init_ussd", "Callback not invoked");
 621         }
 622
 623         dts_pass("tel_ss_init_ussd");
 624 }
 625
 626 static void utc_fail_tel_ss_init_ussd (void)
 627 {
 628         int ret;
 629
 630         ret = tel_send_ss_ussd_request (NULL, NULL, NULL, NULL);
 631         if (ret == TAPI_API_SUCCESS) {
 632                 dts_fail("tel_ss_init_ussd", "Parameter check failed");
 633         }
 634
 635         ret = tel_send_ss_ussd_request (handle, NULL, 0, NULL);
 636         if (ret == TAPI_API_SUCCESS) {
 637                 dts_fail("tel_ss_init_ussd", "Parameter check failed");
 638         }
 639
 640         dts_pass("tel_ss_init_ussd");
 641 }
 642
 643 /**
 644  * tel_ss_cancel_ussd
 645  *
 646  */
 647 static void on_tel_ss_cancel_ussd (TapiHandle *handle, int result, void *data, void *user_data)
 648 {
 649         int *value = user_data;
 650
 651         async_flag = ASYNC_DONE;
 652         util_stop_loop ();
 653
 654         if (*value != 0xC0FFEE) {
 655                 dts_fail("tel_ss_cancel_ussd", "Callback userdata crashed");
 656         }
 657         if (result != 0x0) {
 658                 dts_fail("tel_ss_cancel_ussd", "Operation failed");
 659         }
 660 }
 661
 662 static void utc_tel_ss_cancel_ussd (void)
 663 {
 664         int ret;
 665         int value = 0xC0FFEE;
 666         TelSsUssdMsgInfo_t info;
 667
 668         util_init_loop ();
 669
 670         async_flag = ASYNC_READY;
 671         memset(&info, 0, sizeof(TelSsUssdMsgInfo_t));
 672         info.Type = 0x03;
 673         info.Length = 0x05;
 674         strncpy(info.szString, "*121#", 5);
 675         ret = tel_send_ss_ussd_request (handle, &info,
 676                         on_tel_ss_cancel_ussd, &value);
 677         if (ret != TAPI_API_SUCCESS) {
 678                 dts_fail("tel_ss_cancel_ussd", "Unexpected return");
 679         }
 680
 681         util_start_loop ();
 682         util_free_loop ();
 683
 684         if (async_flag != ASYNC_DONE) {
 685                 dts_fail("tel_ss_cancel_ussd", "Callback not invoked");
 686         }
 687
 688         dts_pass("tel_ss_cancel_ussd");
 689 }
 690
 691 static void utc_fail_tel_ss_cancel_ussd (void)
 692 {
 693         int ret;
 694
 695         ret = tel_send_ss_ussd_request (NULL, NULL, NULL, NULL);
 696         if (ret == TAPI_API_SUCCESS) {
 697                 dts_fail("tel_ss_cancel_ussd", "Parameter check failed");
 698         }
 699
 700         ret = tel_send_ss_ussd_request (handle, NULL, 0, NULL);
 701         if (ret == TAPI_API_SUCCESS) {
 702                 dts_fail("tel_ss_cancel_ussd", "Parameter check failed");
 703         }
 704
 705         dts_pass("tel_ss_cancel_ussd");
 706 }
 707
 708 /* Barring activate and De-activate auto generated functions */
 709
 710 DO_BARRING(tel_barring_baoc_activate, class, barring_type[0], barring_mode[0])
 711 DO_BARRING(tel_barring_baoc_deactivate, class, barring_type[0], barring_mode[1])
 712 DO_BARRING(tel_barring_boic_activate, class, barring_type[1], barring_mode[0])
 713 DO_BARRING(tel_barring_boic_deactivate, class, barring_type[1], barring_mode[1])
 714 DO_BARRING(tel_barring_boic_not_hc_activate, class, barring_type[2], barring_mode[0])
 715 DO_BARRING(tel_barring_boic_not_hc_deactivate, class, barring_type[2], barring_mode[1])
 716 DO_BARRING(tel_barring_baic_activate, class,  barring_type[3], barring_mode[0])
 717 DO_BARRING(tel_barring_baic_deactivate, class,  barring_type[3], barring_mode[1])
 718 DO_BARRING(tel_barring_bic_roam_activate, class,  barring_type[4], barring_mode[0])
 719 DO_BARRING(tel_barring_bic_roam_deactivate, class,  barring_type[4], barring_mode[1])
 720 DO_BARRING(tel_barring_ab_activate, class,  barring_type[5], barring_mode[0])
 721 DO_BARRING(tel_barring_ab_deactivate, class,  barring_type[5], barring_mode[1])
 722 DO_BARRING(tel_barring_aob_activate, class,  barring_type[6], barring_mode[0])
 723 DO_BARRING(tel_barring_aob_deactivate, class,  barring_type[6], barring_mode[1])
 724 DO_BARRING(tel_barring_aib_activate, class,  barring_type[7], barring_mode[0])
 725 DO_BARRING(tel_barring_aib_deactivate, class,  barring_type[7], barring_mode[1])
 726 DO_BARRING(tel_barring_bic_not_sim_activate, class,  barring_type[8], barring_mode[0])
 727 DO_BARRING(tel_barring_bic_not_sim_deactivate, class,  barring_type[8], barring_mode[1])
 728
 729 /* Barring get status auto generated functions */
 730
 731 DO_BARRING_STATUS(tel_barring_baoc_status, class,  barring_type[0])
 732 DO_BARRING_STATUS(tel_barring_boic_status, class,  barring_type[1])
 733 DO_BARRING_STATUS(tel_barring_boic_not_hc_status, class,  barring_type[2])
 734 DO_BARRING_STATUS(tel_barring_baic_status, class,  barring_type[3])
 735 DO_BARRING_STATUS(tel_barring_bic_roam_status, class,  barring_type[4])
 736 DO_BARRING_STATUS(tel_barring_ab_status, class,  barring_type[5])
 737 DO_BARRING_STATUS(tel_barring_aob_status, class,  barring_type[6])
 738 DO_BARRING_STATUS(tel_barring_aib_status, class,  barring_type[7])
 739 DO_BARRING_STATUS(tel_barring_bic_not_sim_status, class,  barring_type[8])
 740
 741 /* Forwarding register and erasure auto generated functions */
 742
 743 DO_FORWARDING(tel_forwarding_cfu_register, class, forwarding_type[0], forwarding_mode[2])
 744 DO_FORWARDING(tel_forwarding_cfu_erasure, class, forwarding_type[0], forwarding_mode[3])
 745 DO_FORWARDING(tel_forwarding_cfb_register, class, forwarding_type[1], forwarding_mode[2])
 746 DO_FORWARDING(tel_forwarding_cfb_erasure, class, forwarding_type[1], forwarding_mode[3])
 747 DO_FORWARDING(tel_forwarding_cfnry_register, class, forwarding_type[2], forwarding_mode[2])
 748 DO_FORWARDING(tel_forwarding_cfnry_erasure, class, forwarding_type[2], forwarding_mode[3])
 749 DO_FORWARDING(tel_forwarding_cfnrc_register, class, forwarding_type[3], forwarding_mode[2])
 750 DO_FORWARDING(tel_forwarding_cfunrc_erasure, class, forwarding_type[3], forwarding_mode[3])
 751 DO_FORWARDING(tel_forwarding_cf_all_register, class, forwarding_type[4], forwarding_mode[2])
 752 DO_FORWARDING(tel_forwarding_cf_all_erasure, class, forwarding_type[4], forwarding_mode[3])
 753 DO_FORWARDING(tel_forwarding_cfc_register, class, forwarding_type[5], forwarding_mode[2])
 754 DO_FORWARDING(tel_forwarding_cfc_erasure, class, forwarding_type[5], forwarding_mode[3])
 755
 756
 757 /* Forwarding get status auto generated functions */
 758
 759 DO_FORWARDING_STATUS(tel_forwarding_cfu_status, class, forwarding_type[0])
 760 DO_FORWARDING_STATUS(tel_forwarding_cfb_status, class, forwarding_type[1])
 761 DO_FORWARDING_STATUS(tel_forwarding_cfnry_status, class, forwarding_type[2])
 762 DO_FORWARDING_STATUS(tel_forwarding_cfnrc_status, class, forwarding_type[3])
 763 DO_FORWARDING_STATUS(tel_forwarding_cf_all_status, class, forwarding_type[4])
 764 DO_FORWARDING_STATUS(tel_forwarding_cfc_status, class, forwarding_type[5])
 765
 766
 767 /* Waiting activate/de-activate Macro */
 768
 769 DO_WAITING(tel_waiting_activate, class, waiting_mode[0])
 770 DO_WAITING(tel_waiting_deactivate, class, waiting_mode[1])
 771
 772 /* CLI set status auto generated functions */
 773
 774 DO_CLI(tel_CLIP_activate, cli_type[0], cli_mode[2])
 775 DO_CLI(tel_CLIP_deactivate, cli_type[0], cli_mode[0])
 776 DO_CLI(tel_CLIR_activate, cli_type[1], cli_mode[2])
 777 DO_CLI(tel_CLIR_deactivate, cli_type[1], cli_mode[0])
 778 DO_CLI(tel_COLP_activate, cli_type[2], cli_mode[2])
 779 DO_CLI(tel_COLP_deactivate, cli_type[2], cli_mode[0])
 780 DO_CLI(tel_COLR_activate, cli_type[3], cli_mode[2])
 781 DO_CLI(tel_COLR_deactivate, cli_type[3], cli_mode[0])
 782 DO_CLI(tel_CDIP_activate, cli_type[4], cli_mode[2])
 783 DO_CLI(tel_CDIP_deactivate, cli_type[4], cli_mode[0])
 784 DO_CLI(tel_CNAP_activate, cli_type[5], cli_mode[2])
 785 DO_CLI(tel_CNAP_deactivate, cli_type[5], cli_mode[0])
 786
 787 /* CLI get status auto generated functions */
 788
 789 DO_CLI_STATUS(tel_CLIP_status, cli_type[0])
 790 DO_CLI_STATUS(tel_CLIR_status, cli_type[1])
 791 DO_CLI_STATUS(tel_COLP_status, cli_type[2])
 792 DO_CLI_STATUS(tel_COLR_status, cli_type[3])
 793 DO_CLI_STATUS(tel_CDIP_status, cli_type[4])
 794 DO_CLI_STATUS(tel_CNAP_status, cli_type[5])
 795
 796
 797 struct tet_testlist tet_testlist[] = {
 798         /* generated TC */
 799         { utc_tel_barring_baoc_activate, 1 },
 800         { utc_fail_tel_barring_baoc_activate, 2 },
 801         { utc_tel_barring_baoc_deactivate, 1 },
 802         { utc_fail_tel_barring_baoc_deactivate, 2 },
 803         { utc_tel_barring_boic_activate, 1 },
 804         { utc_fail_tel_barring_boic_activate, 2 },
 805         { utc_tel_barring_boic_deactivate, 1 },
 806         { utc_fail_tel_barring_boic_deactivate, 2 },
 807         { utc_tel_barring_boic_not_hc_activate, 1 },
 808         { utc_fail_tel_barring_boic_not_hc_activate, 2 },
 809         { utc_tel_barring_boic_not_hc_deactivate, 1 },
 810         { utc_fail_tel_barring_boic_not_hc_deactivate, 2 },
 811         { utc_tel_barring_baic_activate, 1 },
 812         { utc_fail_tel_barring_baic_activate, 2 },
 813         { utc_tel_barring_baic_deactivate, 1 },
 814         { utc_fail_tel_barring_baic_deactivate, 2 },
 815         { utc_tel_barring_bic_roam_activate, 1 },
 816         { utc_fail_tel_barring_bic_roam_activate, 2 },
 817         { utc_tel_barring_bic_roam_deactivate, 1 },
 818         { utc_fail_tel_barring_bic_roam_deactivate, 2 },
 819         { utc_tel_barring_ab_activate, 1 },
 820         { utc_fail_tel_barring_ab_activate, 2 },
 821         { utc_tel_barring_ab_deactivate, 1 },
 822         { utc_fail_tel_barring_ab_deactivate, 2 },
 823         { utc_tel_barring_aob_activate, 1 },
 824         { utc_fail_tel_barring_aob_activate, 2 },
 825         { utc_tel_barring_aob_deactivate, 1 },
 826         { utc_fail_tel_barring_aob_deactivate, 2 },
 827         { utc_tel_barring_aib_activate, 1 },
 828         { utc_fail_tel_barring_aib_activate, 2 },
 829         { utc_tel_barring_aib_deactivate, 1 },
 830         { utc_fail_tel_barring_aib_deactivate, 2 },
 831         { utc_tel_barring_bic_not_sim_activate, 1 },
 832         { utc_fail_tel_barring_bic_not_sim_activate, 2 },
 833         { utc_tel_barring_bic_not_sim_deactivate, 1 },
 834         { utc_fail_tel_barring_bic_not_sim_deactivate, 2 },
 835
 836         { utc_tel_barring_baoc_status, 1 },
 837         { utc_fail_tel_barring_baoc_status, 2 },
 838         { utc_tel_barring_boic_status, 1 },
 839         { utc_fail_tel_barring_boic_status, 2 },
 840         { utc_tel_barring_boic_not_hc_status, 1 },
 841         { utc_fail_tel_barring_boic_not_hc_status, 2 },
 842         { utc_tel_barring_baic_status, 1 },
 843         { utc_fail_tel_barring_baic_status, 2 },
 844         { utc_tel_barring_ab_status, 1 },
 845         { utc_fail_tel_barring_ab_status, 2 },
 846         { utc_tel_barring_bic_roam_status, 1 },
 847         { utc_fail_tel_barring_bic_roam_status, 2 },
 848         { utc_tel_barring_ab_status, 1 },
 849         { utc_fail_tel_barring_ab_status, 2 },
 850         { utc_tel_barring_aob_status, 1 },
 851         { utc_fail_tel_barring_aob_status, 2 },
 852         { utc_tel_barring_aib_status, 1 },
 853         { utc_fail_tel_barring_aib_status, 2 },
 854         { utc_tel_barring_bic_not_sim_status, 1 },
 855         { utc_fail_tel_barring_bic_not_sim_status, 2 },
 856
 857         { utc_tel_forwarding_cfu_register, 1 },
 858         { utc_fail_tel_forwarding_cfu_register, 2 },
 859         { utc_tel_forwarding_cfu_erasure, 1 },
 860         { utc_fail_tel_forwarding_cfu_erasure, 2 },
 861         { utc_tel_forwarding_cfb_register, 1 },
 862         { utc_fail_tel_forwarding_cfb_register, 2 },
 863         { utc_tel_forwarding_cfb_erasure, 1 },
 864         { utc_fail_tel_forwarding_cfb_erasure, 2 },
 865         { utc_tel_forwarding_cfnry_register, 1 },
 866         { utc_fail_tel_forwarding_cfnry_register, 2 },
 867         { utc_tel_forwarding_cfnry_erasure, 1 },
 868         { utc_fail_tel_forwarding_cfnry_erasure, 2 },
 869         { utc_tel_forwarding_cfnrc_register, 1 },
 870         { utc_fail_tel_forwarding_cfnrc_register, 2 },
 871         { utc_tel_forwarding_cfunrc_erasure, 1 },
 872         { utc_fail_tel_forwarding_cfunrc_erasure, 2 },
 873         { utc_tel_forwarding_cf_all_register, 1 },
 874         { utc_fail_tel_forwarding_cf_all_register, 2 },
 875         { utc_tel_forwarding_cf_all_erasure, 1 },
 876         { utc_fail_tel_forwarding_cf_all_erasure, 2 },
 877         { utc_tel_forwarding_cfc_register, 1 },
 878         { utc_fail_tel_forwarding_cfc_register, 2 },
 879         { utc_tel_forwarding_cfc_erasure, 1 },
 880         { utc_fail_tel_forwarding_cfc_erasure, 2 },
 881
 882         { utc_tel_forwarding_cfu_status, 1 },
 883         { utc_fail_tel_forwarding_cfu_status, 2 },
 884         { utc_tel_forwarding_cfb_status, 1 },
 885         { utc_fail_tel_forwarding_cfb_status, 2 },
 886         { utc_tel_forwarding_cfnry_status, 1 },
 887         { utc_fail_tel_forwarding_cfnry_status, 2 },
 888         { utc_tel_forwarding_cfnrc_status, 1 },
 889         { utc_fail_tel_forwarding_cfnrc_status, 2 },
 890         { utc_tel_forwarding_cf_all_status, 1 },
 891         { utc_fail_tel_forwarding_cf_all_status, 2 },
 892         { utc_tel_forwarding_cfc_status, 1 },
 893         { utc_fail_tel_forwarding_cfc_status, 2 },
 894
 895
 896         { utc_tel_waiting_activate, 1 },
 897         { utc_fail_tel_waiting_activate, 2 },
 898         { utc_tel_waiting_deactivate, 1 },
 899         { utc_fail_tel_waiting_deactivate, 2 },
 900
 901         { utc_tel_CLIP_status, 1 },
 902         { utc_fail_tel_CLIP_status, 2 },
 903         { utc_tel_CLIR_status, 1 },
 904         { utc_fail_tel_CLIR_status, 2 },
 905         { utc_tel_COLP_status, 1 },
 906         { utc_fail_tel_COLP_status, 2 },
 907         { utc_tel_COLR_status, 1 },
 908         { utc_fail_tel_COLR_status, 2 },
 909         { utc_tel_CDIP_status, 1 },
 910         { utc_fail_tel_CDIP_status, 2 },
 911         { utc_tel_CNAP_status, 1 },
 912         { utc_fail_tel_CNAP_status, 2 },
 913
 914         { utc_tel_CLIP_activate, 1 },
 915         { utc_fail_tel_CLIP_activate, 2 },
 916         { utc_tel_CLIP_deactivate, 1 },
 917         { utc_fail_tel_CLIP_deactivate, 2 },
 918         { utc_tel_CLIR_activate, 1 },
 919         { utc_fail_tel_CLIR_activate, 2 },
 920         { utc_tel_CLIR_deactivate, 1 },
 921         { utc_fail_tel_CLIR_deactivate, 2 },
 922         { utc_tel_COLP_activate, 1 },
 923         { utc_fail_tel_COLP_activate, 2 },
 924         { utc_tel_COLP_deactivate, 1 },
 925         { utc_fail_tel_COLP_deactivate, 2 },
 926         { utc_tel_COLR_activate, 1 },
 927         { utc_fail_tel_COLR_activate, 2 },
 928         { utc_tel_COLR_deactivate, 1 },
 929         { utc_fail_tel_COLR_deactivate, 2 },
 930         { utc_tel_CDIP_activate, 1 },
 931         { utc_fail_tel_CDIP_activate, 2 },
 932         { utc_tel_CDIP_deactivate, 1 },
 933         { utc_fail_tel_CDIP_deactivate, 2 },
 934         { utc_tel_CNAP_activate, 1 },
 935         { utc_fail_tel_CNAP_activate, 2 },
 936         { utc_tel_CNAP_deactivate, 1 },
 937         { utc_fail_tel_CNAP_deactivate, 2 },
 938
 939         /* custom TC */
 940         { utc_tel_change_ss_barring_password, 1 },
 941         { utc_fail_tel_change_ss_barring_password, 2 },
 942         { utc_tel_ss_waiting_status, 1 },
 943         { utc_fail_tel_ss_waiting_status, 2 },
 944         { utc_tel_ss_init_ussd, 1 },
 945         { utc_fail_tel_ss_init_ussd, 2 },
 946         { utc_tel_ss_cancel_ussd, 1 },
 947         { utc_fail_tel_ss_cancel_ussd, 2 },
 948
 949         { NULL, 0 },
 950 };
 951
 952 static void startup (void)
 953 {
 954         /* start of TC */
 955         tet_printf ("\n SS TC start");
 956
 957         handle = tel_init (NULL);
 958 }
 959
 960 static void cleanup (void)
 961 {
 962         tel_deinit (handle);
 963
 964         /* end of TC */
 965         tet_printf ("\n SS TC end");
 966 }
 967
 968 void (*tet_startup) (void) = startup;
 969 void (*tet_cleanup) (void) = cleanup;
 970