wearable/TC/testcase/utc_sms.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 #include <TelSms.h>
  24
  25 #include <tapi_common.h>
  26 #include <ITapiNetText.h>
  27 #include <TapiUtility.h>
  28
  29 #include "util_common.h"
  30
  31 TapiHandle *handle;
  32 enum async_state async_flag;
  33
  34 /**
  35  * tel_send_sms
  36  *
  37  */
  38 static void on_tel_send_sms(TapiHandle *handle, int result, void *data, void *user_data)
  39 {
  40         int *value = user_data;
  41
  42         async_flag = ASYNC_DONE;
  43         util_stop_loop ();
  44
  45         if (*value != 0xC0FFEE) {
  46                 dts_fail("tel_send_sms", "Callback userdata crashed");
  47         }
  48 }
  49
  50 static void utc_tel_send_sms(void)
  51 {
  52         int ret;
  53         int value = 0xC0FFEE;
  54
  55         TelSmsDatapackageInfo_t *pDataPackage = NULL;
  56
  57         char *tpdu = "TEST SMS";
  58         unsigned char sca[TAPI_SIM_SMSP_ADDRESS_LEN];
  59         int sca_length;
  60
  61         pDataPackage = malloc(sizeof(TelSmsDatapackageInfo_t));
  62         memset (pDataPackage, 0x0, sizeof(TelSmsDatapackageInfo_t));
  63
  64         sca_length = 0x05;
  65         sca[0] = 0x89;
  66         sca[1] = 0x54;
  67         sca[2] = 0x80;
  68         sca[3] = 0x07;
  69         sca[4] = 0x10;
  70
  71         memcpy(pDataPackage->Sca, sca, sca_length);
  72         pDataPackage->MsgLength = strlen(tpdu);
  73         memcpy(pDataPackage->szData, tpdu, pDataPackage->MsgLength);
  74
  75         util_init_loop ();
  76
  77         async_flag = ASYNC_READY;
  78         ret = tel_send_sms(handle, pDataPackage, 0, on_tel_send_sms, &value);
  79         if (ret != TAPI_API_SUCCESS) {
  80                 dts_fail("tel_send_sms", "Unexpected return");
  81         }
  82
  83         free(tpdu);
  84         util_start_loop ();
  85         util_free_loop ();
  86
  87         if (async_flag != ASYNC_DONE) {
  88                 dts_fail("tel_send_sms", "Callback not invoked");
  89         }
  90
  91         dts_pass("tel_send_sms");
  92 }
  93
  94 static void utc_fail_tel_send_sms(void)
  95 {
  96         int ret;
  97
  98         ret = tel_send_sms (NULL, NULL, 0, NULL, NULL);
  99         if (ret == TAPI_API_SUCCESS) {
 100                 dts_fail("tel_send_sms", "Parameter check failed");
 101         }
 102
 103         ret = tel_send_sms (handle, NULL, 0, NULL, NULL);
 104         if (ret == TAPI_API_SUCCESS) {
 105                 dts_fail("tel_send_sms", "Parameter check failed");
 106         }
 107
 108         dts_pass("tel_send_sms");
 109 }
 110
 111 /**
 112  * tel_read_sms_in_sim
 113  *
 114  */
 115 static void on_tel_read_sms_in_sim(TapiHandle *handle, int result, void *data, void *user_data)
 116 {
 117         int *value = user_data;
 118
 119         async_flag = ASYNC_DONE;
 120         util_stop_loop ();
 121
 122         if (*value != 0xC0FFEE) {
 123                 dts_fail("tel_read_sms_in_sim", "Callback userdata crashed");
 124         }
 125 }
 126
 127 static void utc_tel_read_sms_in_sim(void)
 128 {
 129         int ret;
 130         int value = 0xC0FFEE;
 131         int index = 1;
 132
 133         util_init_loop ();
 134
 135         async_flag = ASYNC_READY;
 136         ret = tel_read_sms_in_sim (handle, index, on_tel_read_sms_in_sim, &value);
 137         if (ret != TAPI_API_SUCCESS) {
 138                 dts_fail("tel_read_sms_in_sim", "Unexpected return");
 139         }
 140
 141         util_start_loop ();
 142         util_free_loop ();
 143
 144         if (async_flag != ASYNC_DONE) {
 145                 dts_fail("tel_read_sms_in_sim", "Callback not invoked");
 146         }
 147
 148         dts_pass("tel_read_sms_in_sim");
 149 }
 150
 151 static void utc_fail_tel_read_sms_in_sim(void)
 152 {
 153         int ret;
 154
 155         ret = tel_read_sms_in_sim(NULL, -1, NULL, NULL);
 156         if (ret == TAPI_API_SUCCESS) {
 157                 dts_fail("tel_read_sms_in_sim", "Parameter check failed");
 158         }
 159
 160         ret = tel_read_sms_in_sim(handle, 256, NULL, NULL);
 161         if (ret == TAPI_API_SUCCESS) {
 162                 dts_fail("tel_read_sms_in_sim", "Parameter check failed");
 163         }
 164
 165         dts_pass("tel_read_sms_in_sim");
 166 }
 167
 168 /**
 169  * tel_write_sms_in_sim
 170  *
 171  */
 172 static void on_tel_write_sms_in_sim(TapiHandle *handle, int result, void *data, void *user_data)
 173 {
 174         int *value = user_data;
 175
 176         async_flag = ASYNC_DONE;
 177         util_stop_loop ();
 178
 179         if (*value != 0xC0FFEE) {
 180                 dts_fail("tel_write_sms_in_sim", "Callback userdata crashed");
 181         }
 182 }
 183
 184 static void utc_tel_write_sms_in_sim(void)
 185 {
 186         int ret;
 187         int value = 0xC0FFEE;
 188         TelSmsData_t *pWriteData;
 189         unsigned char sca[TAPI_SIM_SMSP_ADDRESS_LEN];
 190         char *tpdu = "WRITE SMS";
 191         int sca_length;
 192         pWriteData->SimIndex = 1;
 193         pWriteData->MsgStatus = TAPI_NETTEXT_STATUS_READ;
 194
 195         sca_length = 0x05;
 196         sca[0] = 0x89;
 197         sca[1] = 0x54;
 198         sca[2] = 0x80;
 199         sca[3] = 0x07;
 200         sca[4] = 0x10;
 201
 202         pWriteData->SmsData.MsgLength = strlen(tpdu);
 203
 204         memcpy(pWriteData->SmsData.Sca, sca, sca_length);
 205         memcpy(pWriteData->SmsData.szData, tpdu, pWriteData->SmsData.MsgLength);
 206
 207         util_init_loop ();
 208
 209         async_flag = ASYNC_READY;
 210         ret = tel_write_sms_in_sim(handle, pWriteData, on_tel_write_sms_in_sim, &value);
 211         if (ret != TAPI_API_SUCCESS) {
 212                 dts_fail("tel_write_sms_in_sim", "Unexpected return");
 213         }
 214
 215         util_start_loop ();
 216         util_free_loop ();
 217
 218         if (async_flag != ASYNC_DONE) {
 219                 dts_fail("tel_write_sms_in_sim", "Callback not invoked");
 220         }
 221
 222         dts_pass("tel_write_sms_in_sim");
 223 }
 224
 225 static void utc_fail_tel_write_sms_in_sim(void)
 226 {
 227         int ret;
 228
 229         ret = tel_write_sms_in_sim(NULL, NULL, NULL, NULL);
 230         if (ret == TAPI_API_SUCCESS) {
 231                 dts_fail("tel_write_sms_in_sim", "Parameter check failed");
 232         }
 233
 234         ret = tel_write_sms_in_sim(handle, NULL, NULL, NULL);
 235         if (ret == TAPI_API_SUCCESS) {
 236                 dts_fail("tel_write_sms_in_sim", "Parameter check failed");
 237         }
 238
 239         dts_pass("tel_write_sms_in_sim");
 240 }
 241
 242 /**
 243  * tel_delete_sms_in_sim
 244  *
 245  */
 246 static void on_tel_delete_sms_in_sim(TapiHandle *handle, int result, void *data, void *user_data)
 247 {
 248         int *value = user_data;
 249
 250         async_flag = ASYNC_DONE;
 251         util_stop_loop ();
 252
 253         if (*value != 0xC0FFEE) {
 254                 dts_fail("tel_delete_sms_in_sim", "Callback userdata crashed");
 255         }
 256 }
 257
 258 static void utc_tel_delete_sms_in_sim(void)
 259 {
 260         int ret;
 261         int value = 0xC0FFEE;
 262         int index = 1;
 263
 264         util_init_loop ();
 265
 266         async_flag = ASYNC_READY;
 267         ret = tel_delete_sms_in_sim(handle, index, on_tel_delete_sms_in_sim, &value);
 268         if (ret != TAPI_API_SUCCESS) {
 269                 dts_fail("tel_delete_sms_in_sim", "Unexpected return");
 270         }
 271
 272         util_start_loop ();
 273         util_free_loop ();
 274
 275         if (async_flag != ASYNC_DONE) {
 276                 dts_fail("tel_delete_sms_in_sim", "Callback not invoked");
 277         }
 278
 279         dts_pass("tel_delete_sms_in_sim");
 280 }
 281
 282 static void utc_fail_tel_delete_sms_in_sim(void)
 283 {
 284         int ret;
 285
 286         ret = tel_delete_sms_in_sim (NULL, -2, NULL, NULL);
 287         if (ret == TAPI_API_SUCCESS) {
 288                 dts_fail("tel_delete_sms_in_sim", "Parameter check failed");
 289         }
 290
 291         ret = tel_delete_sms_in_sim (handle, 256, NULL, NULL);
 292         if (ret == TAPI_API_SUCCESS) {
 293                 dts_fail("tel_delete_sms_in_sim", "Parameter check failed");
 294         }
 295
 296         dts_pass("tel_delete_sms_in_sim");
 297 }
 298
 299 /**
 300  * tel_get_sms_sca
 301  *
 302  */
 303 static void on_tel_get_sms_sca(TapiHandle *handle, int result, void *data, void *user_data)
 304 {
 305         int *value = user_data;
 306
 307         async_flag = ASYNC_DONE;
 308         util_stop_loop ();
 309
 310         if (*value != 0xC0FFEE) {
 311                 dts_fail("tel_get_sms_sca", "Callback userdata crashed");
 312         }
 313 }
 314
 315 static void utc_tel_get_sms_sca(void)
 316 {
 317         int ret;
 318         int value = 0xC0FFEE;
 319         int index = 1;
 320
 321         util_init_loop ();
 322
 323         async_flag = ASYNC_READY;
 324         ret = tel_get_sms_sca(handle, index, on_tel_get_sms_sca, &value);
 325         if (ret != TAPI_API_SUCCESS) {
 326                 dts_fail("tel_get_sms_sca", "Unexpected return");
 327         }
 328
 329         util_start_loop ();
 330         util_free_loop ();
 331
 332         if (async_flag != ASYNC_DONE) {
 333                 dts_fail("tel_get_sms_sca", "Callback not invoked");
 334         }
 335
 336         dts_pass("tel_get_sms_sca");
 337 }
 338
 339 static void utc_fail_tel_get_sms_sca(void)
 340 {
 341         int ret;
 342
 343         ret = tel_get_sms_sca(NULL, -1, NULL, NULL);
 344         if (ret == TAPI_API_SUCCESS) {
 345                 dts_fail("tel_get_sms_sca", "Parameter check failed");
 346         }
 347
 348         ret = tel_get_sms_sca(handle, 256, NULL, NULL);
 349         if (ret == TAPI_API_SUCCESS) {
 350                 dts_fail("tel_get_sms_sca", "Parameter check failed");
 351         }
 352
 353
 354         dts_pass("tel_get_sms_sca");
 355 }
 356
 357 /**
 358  * tel_set_sms_sca
 359  *
 360  */
 361 static void on_tel_set_sms_sca(TapiHandle *handle, int result, void *data, void *user_data)
 362 {
 363         int *value = user_data;
 364
 365         async_flag = ASYNC_DONE;
 366         util_stop_loop ();
 367
 368         if (*value != 0xC0FFEE) {
 369                 dts_fail("tel_set_sms_sca", "Callback userdata crashed");
 370         }
 371 }
 372
 373 static void utc_tel_set_sms_sca(void)
 374 {
 375         int ret;
 376         int value = 0xC0FFEE;
 377         int index = 1;
 378         TelSmsAddressInfo_t *sca = NULL;
 379
 380         sca->DialNumLen = 0x5;
 381         sca->Npi = TAPI_SIM_NPI_ISDN_TEL;
 382         sca->Ton = TAPI_SIM_TON_INTERNATIONAL;
 383         sca->szDiallingNum[0] = 0x89;
 384         sca->szDiallingNum[1] = 0x54;
 385         sca->szDiallingNum[2] = 0x80;
 386         sca->szDiallingNum[3] = 0x07;
 387         sca->szDiallingNum[4] = 0x10;
 388
 389         util_init_loop ();
 390
 391         async_flag = ASYNC_READY;
 392         ret = tel_set_sms_sca(handle, sca, index, on_tel_set_sms_sca, &value);
 393         if (ret != TAPI_API_SUCCESS) {
 394                 dts_fail("tel_set_sms_sca", "Unexpected return");
 395         }
 396
 397         util_start_loop ();
 398         util_free_loop ();
 399
 400         if (async_flag != ASYNC_DONE) {
 401                 dts_fail("tel_set_sms_sca", "Callback not invoked");
 402         }
 403
 404         dts_pass("tel_set_sms_sca");
 405 }
 406
 407 static void utc_fail_tel_set_sms_sca(void)
 408 {
 409         int ret;
 410
 411         ret = tel_set_sms_sca(NULL, NULL, -1, NULL, NULL);
 412         if (ret == TAPI_API_SUCCESS) {
 413                 dts_fail("tel_set_sms_sca", "Parameter check failed");
 414         }
 415
 416         ret = tel_set_sms_sca(handle, NULL, -1, NULL, NULL);
 417         if (ret == TAPI_API_SUCCESS) {
 418                 dts_fail("tel_set_sms_sca", "Parameter check failed");
 419         }
 420
 421         dts_pass("tel_set_sms_sca");
 422 }
 423
 424 /**
 425  * tel_set_sms_cb_config
 426  *
 427  */
 428 static void on_tel_set_sms_cb_config(TapiHandle *handle, int result, void *data, void *user_data)
 429 {
 430         int *value = user_data;
 431
 432         async_flag = ASYNC_DONE;
 433         util_stop_loop ();
 434
 435         if (*value != 0xC0FFEE) {
 436                 dts_fail("tel_set_sms_cb_config", "Callback userdata crashed");
 437         }
 438 }
 439
 440 static void utc_tel_set_sms_cb_config(void)
 441 {
 442         int ret;
 443         int value = 0xC0FFEE;
 444         int i;
 445         TelSmsCbConfig_t *pCBConfig = NULL;
 446         pCBConfig->CBEnabled = 0x01;
 447         pCBConfig->Net3gppType = 0x01;
 448         pCBConfig->MsgIdMaxCount = 0x10;
 449         pCBConfig->MsgIdRangeCount = 0x05;
 450
 451         for (i = 0; i < pCBConfig->MsgIdRangeCount; i++) {
 452                 pCBConfig->MsgIDs[i].Net3gpp.FromMsgId = 0x01;
 453                 pCBConfig->MsgIDs[i].Net3gpp.ToMsgId = 0x02;
 454                 pCBConfig->MsgIDs[i].Net3gpp.Selected = 0x01;
 455         }
 456         util_init_loop ();
 457
 458         async_flag = ASYNC_READY;
 459         ret = tel_set_sms_cb_config(handle, pCBConfig, on_tel_set_sms_cb_config, &value);
 460         if (ret != TAPI_API_SUCCESS) {
 461                 dts_fail("tel_set_sms_cb_config", "Unexpected return");
 462         }
 463
 464         util_start_loop ();
 465         util_free_loop ();
 466
 467         if (async_flag != ASYNC_DONE) {
 468                 dts_fail("tel_set_sms_cb_config", "Callback not invoked");
 469         }
 470
 471         dts_pass("tel_set_sms_cb_config");
 472 }
 473
 474 static void utc_fail_tel_set_sms_cb_config(void)
 475 {
 476         int ret;
 477
 478         ret = tel_set_sms_cb_config(NULL, NULL, NULL, NULL);
 479         if (ret == TAPI_API_SUCCESS) {
 480                 dts_fail("tel_set_sms_cb_config", "Parameter check failed");
 481         }
 482
 483         ret = tel_set_sms_cb_config(handle, NULL, NULL, NULL);
 484         if (ret == TAPI_API_SUCCESS) {
 485                 dts_fail("tel_set_sms_cb_config", "Parameter check failed");
 486         }
 487
 488         dts_pass("tel_set_sms_cb_config");
 489 }
 490
 491 /**
 492  * tel_set_sms_memory_status
 493  *
 494  */
 495 static void on_tel_set_sms_memory_status(TapiHandle *handle, int result, void *data, void *user_data)
 496 {
 497         int *value = user_data;
 498
 499         async_flag = ASYNC_DONE;
 500         util_stop_loop ();
 501
 502         if (*value != 0xC0FFEE) {
 503                 dts_fail("tel_set_sms_memory_status", "Callback userdata crashed");
 504         }
 505 }
 506
 507 static void utc_tel_set_sms_memory_status(void)
 508 {
 509         int ret;
 510         int value = 0xC0FFEE;
 511         int memory_available = 2;
 512
 513         util_init_loop ();
 514
 515         async_flag = ASYNC_READY;
 516         ret = tel_set_sms_memory_status(handle, memory_available, on_tel_set_sms_memory_status, &value);
 517         if (ret != TAPI_API_SUCCESS) {
 518                 dts_fail("tel_set_sms_memory_status", "Unexpected return");
 519         }
 520
 521         util_start_loop ();
 522         util_free_loop ();
 523
 524         if (async_flag != ASYNC_DONE) {
 525                 dts_fail("tel_set_sms_memory_status", "Callback not invoked");
 526         }
 527
 528         dts_pass("tel_set_sms_memory_status");
 529 }
 530
 531 static void utc_fail_tel_set_sms_memory_status(void)
 532 {
 533         int ret;
 534
 535         ret = tel_set_sms_memory_status(NULL, -1, NULL, NULL);
 536         if (ret == TAPI_API_SUCCESS) {
 537                 dts_fail("tel_set_sms_memory_status", "Parameter check failed");
 538         }
 539
 540         ret = tel_set_sms_memory_status(handle, -1, NULL, NULL);
 541         if (ret == TAPI_API_SUCCESS) {
 542                 dts_fail("tel_set_sms_memory_status", "Parameter check failed");
 543         }
 544
 545         ret = tel_set_sms_memory_status(handle, 4, NULL, NULL);
 546         if (ret == TAPI_API_SUCCESS) {
 547                 dts_fail("tel_set_sms_memory_status", "Parameter check failed");
 548         }
 549
 550         dts_pass("tel_set_sms_memory_status");
 551 }
 552
 553 /**
 554  * tel_set_sms_preferred_bearer
 555  *
 556  */
 557 static void on_tel_set_sms_preferred_bearer(TapiHandle *handle, int result, void *data, void *user_data)
 558 {
 559         int *value = user_data;
 560
 561         async_flag = ASYNC_DONE;
 562         util_stop_loop ();
 563
 564         if (*value != 0xC0FFEE) {
 565                 dts_fail("tel_set_sms_preferred_bearer", "Callback userdata crashed");
 566         }
 567 }
 568
 569 static void utc_tel_set_sms_preferred_bearer(void)
 570 {
 571         int ret;
 572         int value = 0xC0FFEE;
 573
 574         util_init_loop ();
 575
 576         async_flag = ASYNC_READY;
 577         ret = tel_set_sms_preferred_bearer(handle, TAPI_NETTEXT_BEARER_PS_ONLY, on_tel_set_sms_preferred_bearer, &value);
 578         if (ret != TAPI_API_SUCCESS) {
 579                 dts_fail("tel_set_sms_preferred_bearer", "Unexpected return");
 580         }
 581
 582         util_start_loop ();
 583         util_free_loop ();
 584
 585         if (async_flag != ASYNC_DONE) {
 586                 dts_fail("tel_set_sms_preferred_bearer", "Callback not invoked");
 587         }
 588
 589         dts_pass("tel_set_sms_preferred_bearer");
 590 }
 591
 592 static void utc_fail_tel_set_sms_preferred_bearer(void)
 593 {
 594         int ret;
 595
 596         ret = tel_set_sms_preferred_bearer(NULL, -1, NULL, NULL);
 597         if (ret == TAPI_API_SUCCESS) {
 598                 dts_fail("tel_set_sms_preferred_bearer", "Parameter check failed");
 599         }
 600
 601         ret = tel_set_sms_preferred_bearer(handle, -1, NULL, NULL);
 602         if (ret == TAPI_API_SUCCESS) {
 603                 dts_fail("tel_set_sms_preferred_bearer", "Parameter check failed");
 604         }
 605         dts_pass("tel_set_sms_preferred_bearer");
 606 }
 607
 608 /**
 609  * tel_send_sms_deliver_report
 610  *
 611  */
 612 static void on_tel_send_sms_deliver_report(TapiHandle *handle, int result, void *data, void *user_data)
 613 {
 614         int *value = user_data;
 615
 616         async_flag = ASYNC_DONE;
 617         util_stop_loop ();
 618
 619         if (*value != 0xC0FFEE) {
 620                 dts_fail("tel_send_sms_deliver_report", "Callback userdata crashed");
 621         }
 622 }
 623
 624 static void utc_tel_send_sms_deliver_report(void)
 625 {
 626         int ret;
 627         int value = 0xC0FFEE;
 628         TelSmsDatapackageInfo_t *pDataPackage = NULL;
 629
 630         char *tpdu = "TEST SMS";
 631         unsigned char sca[TAPI_SIM_SMSP_ADDRESS_LEN];
 632         int sca_length;
 633
 634         pDataPackage = malloc(sizeof(TelSmsDatapackageInfo_t));
 635         memset (pDataPackage, 0x0, sizeof(TelSmsDatapackageInfo_t));
 636
 637         sca_length = 0x05;
 638         sca[0] = 0x89;
 639         sca[1] = 0x54;
 640         sca[2] = 0x80;
 641         sca[3] = 0x07;
 642         sca[4] = 0x10;
 643
 644         memcpy(pDataPackage->Sca, sca, sca_length);
 645         pDataPackage->MsgLength = strlen(tpdu);
 646         memcpy(pDataPackage->szData, tpdu, pDataPackage->MsgLength);
 647
 648
 649         util_init_loop ();
 650
 651         async_flag = ASYNC_READY;
 652         ret = tel_send_sms_deliver_report(handle, pDataPackage, TAPI_NETTEXT_SENDSMS_SUCCESS, on_tel_send_sms_deliver_report, &value);
 653         if (ret != TAPI_API_SUCCESS) {
 654                 dts_fail("tel_send_sms_deliver_report", "Unexpected return");
 655         }
 656
 657         util_start_loop ();
 658         util_free_loop ();
 659
 660         if (async_flag != ASYNC_DONE) {
 661                 dts_fail("tel_send_sms_deliver_report", "Callback not invoked");
 662         }
 663
 664         dts_pass("tel_send_sms_deliver_report");
 665 }
 666
 667 static void utc_fail_tel_send_sms_deliver_report(void)
 668 {
 669         int ret;
 670
 671         ret = tel_send_sms_deliver_report(NULL, NULL, -1, NULL, NULL);
 672         if (ret == TAPI_API_SUCCESS) {
 673                 dts_fail("tel_send_sms_deliver_report", "Parameter check failed");
 674         }
 675
 676         dts_pass("tel_send_sms_deliver_report");
 677 }
 678
 679 /**
 680  * tel_set_sms_message_status
 681  *
 682  */
 683 static void on_tel_set_sms_message_status(TapiHandle *handle, int result, void *data, void *user_data)
 684 {
 685         int *value = user_data;
 686
 687         async_flag = ASYNC_DONE;
 688         util_stop_loop ();
 689
 690         if (*value != 0xC0FFEE) {
 691                 dts_fail("tel_set_sms_message_status", "Callback userdata crashed");
 692         }
 693 }
 694
 695 static void utc_tel_set_sms_message_status(void)
 696 {
 697         int ret;
 698         int value = 0xC0FFEE;
 699         int index = 1;
 700
 701         util_init_loop ();
 702
 703         async_flag = ASYNC_READY;
 704         ret = tel_set_sms_message_status(handle, index, TAPI_NETTEXT_STATUS_READ, on_tel_set_sms_message_status, &value);
 705         if (ret != TAPI_API_SUCCESS) {
 706                 dts_fail("tel_set_sms_message_status", "Unexpected return");
 707         }
 708
 709         util_start_loop ();
 710         util_free_loop ();
 711
 712         if (async_flag != ASYNC_DONE) {
 713                 dts_fail("tel_set_sms_message_status", "Callback not invoked");
 714         }
 715
 716         dts_pass("tel_set_sms_message_status");
 717 }
 718
 719 static void utc_fail_tel_set_sms_message_status(void)
 720 {
 721         int ret;
 722
 723         ret = tel_set_sms_message_status(NULL, -2, -1, NULL, NULL);
 724         if (ret == TAPI_API_SUCCESS) {
 725                 dts_fail("tel_set_sms_message_status", "Parameter check failed");
 726         }
 727
 728         dts_pass("tel_set_sms_message_status");
 729 }
 730
 731 /**
 732  * tel_get_sms_parameters
 733  *
 734  */
 735 static void on_tel_get_sms_parameters(TapiHandle *handle, int result, void *data, void *user_data)
 736 {
 737         int *value = user_data;
 738
 739         async_flag = ASYNC_DONE;
 740         util_stop_loop ();
 741
 742         if (*value != 0xC0FFEE) {
 743                 dts_fail("tel_get_sms_parameters", "Callback userdata crashed");
 744         }
 745 }
 746
 747 static void utc_tel_get_sms_parameters(void)
 748 {
 749         int ret;
 750         int value = 0xC0FFEE;
 751         int index = 1;
 752
 753         util_init_loop ();
 754
 755         async_flag = ASYNC_READY;
 756         ret = tel_get_sms_parameters(handle, index, on_tel_get_sms_parameters, &value);
 757         if (ret != TAPI_API_SUCCESS) {
 758                 dts_fail("tel_get_sms_parameters", "Unexpected return");
 759         }
 760
 761         util_start_loop ();
 762         util_free_loop ();
 763
 764         if (async_flag != ASYNC_DONE) {
 765                 dts_fail("tel_get_sms_parameters", "Callback not invoked");
 766         }
 767
 768         dts_pass("tel_get_sms_parameters");
 769 }
 770
 771 static void utc_fail_tel_get_sms_parameters(void)
 772 {
 773         int ret;
 774
 775         ret = tel_get_sms_parameters(NULL, -1, NULL, NULL);
 776         if (ret == TAPI_API_SUCCESS) {
 777                 dts_fail("tel_get_sms_parameters", "Parameter check failed");
 778         }
 779
 780         ret = tel_get_sms_parameters(handle, 256, NULL, NULL);
 781         if (ret == TAPI_API_SUCCESS) {
 782                 dts_fail("tel_get_sms_parameters", "Parameter check failed");
 783         }
 784
 785         dts_pass("tel_get_sms_parameters");
 786 }
 787
 788 /**
 789  * tel_set_sms_parameters
 790  *
 791  */
 792 static void on_tel_set_sms_parameters(TapiHandle *handle, int result, void *data, void *user_data)
 793 {
 794         int *value = user_data;
 795
 796         async_flag = ASYNC_DONE;
 797         util_stop_loop ();
 798
 799         if (*value != 0xC0FFEE) {
 800                 dts_fail("tel_set_sms_parameters", "Callback userdata crashed");
 801         }
 802 }
 803
 804 static void utc_tel_set_sms_parameters(void)
 805 {
 806         int ret;
 807         int value = 0xC0FFEE;
 808         TelSmsParams_t *pSmsSetParameters = NULL;
 809
 810         char* name = "airtel";
 811         char* num = "0103001408";
 812         char* sca = "9845087001";
 813
 814         pSmsSetParameters->RecordIndex = 0x00;
 815         pSmsSetParameters->RecordLen = 31;
 816         pSmsSetParameters->AlphaIdLen = 3;
 817         memcpy (&pSmsSetParameters->szAlphaId, name, strlen (name));
 818
 819         pSmsSetParameters->ParamIndicator = 0xe0;
 820         pSmsSetParameters->TpDestAddr.DialNumLen = 10;
 821         pSmsSetParameters->TpDestAddr.Ton = 1;
 822         pSmsSetParameters->TpDestAddr.Npi = 1;
 823
 824         pSmsSetParameters->TpSvcCntrAddr.DialNumLen = 10;
 825         pSmsSetParameters->TpSvcCntrAddr.Ton = 1;
 826         pSmsSetParameters->TpSvcCntrAddr.Npi = 1;
 827
 828         memcpy (pSmsSetParameters->TpDestAddr.szDiallingNum, num, strlen (num));
 829         memcpy (pSmsSetParameters->TpSvcCntrAddr.szDiallingNum, sca, strlen (sca));
 830         pSmsSetParameters->TpProtocolId = 3;
 831         pSmsSetParameters->TpDataCodingScheme = 2;
 832         pSmsSetParameters->TpValidityPeriod = 1;
 833
 834         util_init_loop ();
 835
 836         async_flag = ASYNC_READY;
 837         ret = tel_set_sms_parameters(handle, pSmsSetParameters, on_tel_set_sms_parameters, &value);
 838         if (ret != TAPI_API_SUCCESS) {
 839                 dts_fail("tel_set_sms_parameters", "Unexpected return");
 840         }
 841
 842         util_start_loop ();
 843         util_free_loop ();
 844
 845         if (async_flag != ASYNC_DONE) {
 846                 dts_fail("tel_set_sms_parameters", "Callback not invoked");
 847         }
 848
 849         dts_pass("tel_set_sms_parameters");
 850 }
 851
 852 static void utc_fail_tel_set_sms_parameters(void)
 853 {
 854         int ret;
 855
 856         ret = tel_set_sms_parameters(NULL, NULL, NULL, NULL);
 857         if (ret == TAPI_API_SUCCESS) {
 858                 dts_fail("tel_set_sms_parameters", "Parameter check failed");
 859         }
 860
 861         dts_pass("tel_set_sms_parameters");
 862 }
 863
 864 static void utc_tel_check_sms_device_status(void)
 865 {
 866         int ret;
 867         int readyStatus;
 868
 869         ret = tel_check_sms_device_status(handle, &readyStatus);
 870         if (ret != TAPI_API_SUCCESS) {
 871                 dts_fail("tel_set_sms_parameters", "Unexpected return");
 872         }
 873
 874         dts_pass("tel_set_sms_parameters");
 875 }
 876
 877 static void utc_fail_tel_check_sms_device_status(void)
 878 {
 879         int ret;
 880
 881         ret = tel_check_sms_device_status(NULL, NULL);
 882         if (ret == TAPI_API_SUCCESS) {
 883                 dts_fail("tel_set_sms_parameters", "Parameter check failed");
 884         }
 885
 886         dts_pass("tel_set_sms_parameters");
 887 }
 888
 889
 890 /**
 891  * Generate default TC for no-additional-parameter type API
 892  *
 893  */
 894 DO(tel_get_sms_count)
 895 DO(tel_get_sms_cb_config)
 896 DO(tel_get_sms_preferred_bearer)
 897 DO(tel_get_sms_parameter_count)
 898
 899 struct tet_testlist tet_testlist[] = {
 900         /* generated TC */
 901         { utc_tel_get_sms_count, 1 },
 902         { utc_fail_tel_get_sms_count, 2 },
 903         { utc_tel_get_sms_cb_config, 1 },
 904         { utc_fail_tel_get_sms_cb_config, 2 },
 905         { utc_tel_get_sms_preferred_bearer, 1 },
 906         { utc_fail_tel_get_sms_preferred_bearer, 2 },
 907         { utc_tel_get_sms_parameter_count, 1 },
 908         { utc_fail_tel_get_sms_parameter_count, 2 },
 909
 910         /* custom TC */
 911         { utc_tel_send_sms, 1 },
 912         { utc_fail_tel_send_sms, 2 },
 913         { utc_tel_read_sms_in_sim, 1 },
 914         { utc_fail_tel_read_sms_in_sim, 2 },
 915         { utc_tel_write_sms_in_sim, 1 },
 916         { utc_fail_tel_write_sms_in_sim, 2 },
 917         { utc_tel_delete_sms_in_sim, 1 },
 918         { utc_fail_tel_delete_sms_in_sim, 2 },
 919         { utc_tel_get_sms_sca, 1 },
 920         { utc_fail_tel_get_sms_sca, 2 },
 921         { utc_tel_set_sms_sca, 1 },
 922         { utc_fail_tel_set_sms_sca, 2 },
 923         { utc_tel_set_sms_cb_config, 1 },
 924         { utc_fail_tel_set_sms_cb_config, 2 },
 925         { utc_tel_set_sms_memory_status, 1 },
 926         { utc_fail_tel_set_sms_memory_status, 2 },
 927         { utc_tel_set_sms_preferred_bearer, 1 },
 928         { utc_fail_tel_set_sms_preferred_bearer, 2 },
 929         { utc_tel_send_sms_deliver_report, 1 },
 930         { utc_fail_tel_send_sms_deliver_report, 2 },
 931         { utc_tel_set_sms_message_status, 1 },
 932         { utc_fail_tel_set_sms_message_status, 2 },
 933         { utc_tel_get_sms_parameters, 1 },
 934         { utc_fail_tel_get_sms_parameters, 2 },
 935         { utc_tel_set_sms_parameters, 1 },
 936         { utc_fail_tel_set_sms_parameters, 2 },
 937         { utc_tel_check_sms_device_status, 1 },
 938         { utc_fail_tel_check_sms_device_status, 2 },
 939         { NULL, 0 },
 940 };
 941
 942 static void startup (void)
 943 {
 944         /* start of TC */
 945         tet_printf ("\n TC start");
 946
 947         handle = tel_init (NULL);
 948 }
 949
 950 static void cleanup (void)
 951 {
 952         tel_deinit (handle);
 953
 954         /* end of TC */
 955         tet_printf ("\n TC end");
 956 }
 957
 958 void (*tet_startup) (void) = startup;
 959 void (*tet_cleanup) (void) = cleanup;