wearable/TC/testcase/utc_modem.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ankit Jogi <ankit.jogi@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 <ITapiModem.h>
  26 #include <TapiUtility.h>
  27
  28 #include "util_common.h"
  29
  30 TapiHandle *handle;
  31 enum async_state async_flag;
  32
  33 /**
  34  * tel_process_power_command
  35  *
  36  */
  37 static void on_tel_process_power_command (TapiHandle *handle, int result,
  38                 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_process_power_command", "Callback userdata crashed");
  47         }
  48 }
  49
  50 static void utc_tel_process_power_command (void)
  51 {
  52         int ret;
  53         int value = 0xC0FFEE;
  54         tapi_power_phone_cmd_t cmd;
  55
  56         cmd = 1;
  57
  58         util_init_loop ();
  59
  60         async_flag = ASYNC_READY;
  61         ret = tel_process_power_command (handle, cmd, on_tel_process_power_command, &value);
  62         if (ret != TAPI_API_SUCCESS) {
  63                 dts_fail("tel_process_power_command", "Unexpected return");
  64         }
  65
  66         util_start_loop ();
  67         util_free_loop ();
  68
  69         if (async_flag != ASYNC_DONE) {
  70                 dts_fail("tel_process_power_command", "Callback not invoked");
  71         }
  72
  73         dts_pass("tel_process_power_command");
  74 }
  75
  76 static void utc_fail_tel_process_power_command (void)
  77 {
  78         int ret;
  79
  80         ret = tel_process_power_command (NULL, 1, NULL, NULL);
  81         if (ret == TAPI_API_SUCCESS) {
  82                 dts_fail("tel_process_power_command", "Parameter check failed");
  83         }
  84
  85         ret = tel_process_power_command (handle, 3, NULL, NULL);
  86         if (ret == TAPI_API_SUCCESS) {
  87                 dts_fail("tel_process_power_command", "Parameter check failed");
  88         }
  89
  90         dts_pass("tel_process_power_command");
  91 }
  92
  93 /**
  94  * tel_set_flight_mode
  95  *
  96  */
  97 static void on_tel_set_flight_mode (TapiHandle *handle, int result,
  98                 void *data, void *user_data)
  99 {
 100         int *value = user_data;
 101
 102         async_flag = ASYNC_DONE;
 103         util_stop_loop ();
 104
 105         if (*value != 0xC0FFEE) {
 106                 dts_fail("tel_set_flight_mode", "Callback userdata crashed");
 107         }
 108 }
 109
 110 static void utc_tel_set_flight_mode (void)
 111 {
 112         int ret;
 113         int value = 0xC0FFEE;
 114         tapi_power_flight_mode_type_t mode;
 115
 116         mode = 1;
 117
 118         util_init_loop ();
 119
 120         async_flag = ASYNC_READY;
 121         ret = tel_set_flight_mode (handle, mode, on_tel_set_flight_mode, &value);
 122         if (ret != TAPI_API_SUCCESS) {
 123                 dts_fail("tel_set_flight_mode", "Unexpected return");
 124         }
 125
 126         util_start_loop ();
 127         util_free_loop ();
 128
 129         if (async_flag != ASYNC_DONE) {
 130                 dts_fail("tel_set_flight_mode", "Callback not invoked");
 131         }
 132
 133         dts_pass("tel_set_flight_mode");
 134 }
 135
 136 static void utc_fail_tel_set_flight_mode (void)
 137 {
 138         int ret;
 139
 140         ret = tel_set_flight_mode (NULL, 1, NULL, NULL);
 141         if (ret == TAPI_API_SUCCESS) {
 142                 dts_fail("tel_set_flight_mode", "Parameter check failed");
 143         }
 144
 145         ret = tel_set_flight_mode (handle, 3, NULL, NULL);
 146         if (ret == TAPI_API_SUCCESS) {
 147                 dts_fail("tel_set_flight_mode", "Parameter check failed");
 148         }
 149
 150         dts_pass("tel_set_flight_mode");
 151 }
 152
 153 /**
 154  * tel_get_misc_me_version_sync
 155  *
 156  */
 157 static void utc_tel_get_misc_me_version_sync (void)
 158 {
 159         TelMiscVersionInformation *ret = NULL;
 160
 161         util_init_loop ();
 162
 163         async_flag = ASYNC_READY;
 164         ret = tel_get_misc_me_version_sync (handle);
 165         if (ret == NULL) {
 166                 dts_fail("tel_get_misc_me_version_sync", "Unexpected return");
 167         }
 168
 169         dts_pass("tel_get_misc_me_version_sync");
 170 }
 171
 172 static void utc_fail_tel_get_misc_me_version_sync (void)
 173 {
 174         TelMiscVersionInformation *ret = NULL;
 175
 176         ret = tel_get_misc_me_version_sync (NULL);
 177         if (ret != NULL) {
 178                 dts_fail("tel_get_misc_me_version_sync", "Unexpected return");
 179         }
 180
 181         dts_pass("tel_get_misc_me_version_sync");
 182 }
 183
 184 /**
 185  * tel_get_misc_me_sn_sync
 186  *
 187  */
 188 static void utc_tel_get_misc_me_sn_sync (void)
 189 {
 190         char *ret = NULL;
 191
 192         util_init_loop ();
 193
 194         ret = tel_get_misc_me_sn_sync (handle);
 195         if (ret == NULL) {
 196                 dts_fail("tel_get_misc_me_sn_sync", "Unexpected return");
 197         }
 198
 199         dts_pass("tel_get_misc_me_sn_sync");
 200 }
 201
 202 static void utc_fail_tel_get_misc_me_sn_sync (void)
 203 {
 204         char *ret = NULL;
 205
 206         ret = tel_get_misc_me_sn_sync (NULL);
 207         if (ret != NULL) {
 208                 dts_fail("tel_get_misc_me_sn_sync", "Unexpected return");
 209         }
 210
 211         dts_pass("tel_get_misc_me_sn_sync");
 212 }
 213
 214 /**
 215  * tel_get_misc_me_sn_sync
 216  *
 217  */
 218 static void utc_tel_get_misc_me_imei_sync (void)
 219 {
 220         char *ret = NULL;
 221
 222         util_init_loop ();
 223
 224         ret = tel_get_misc_me_imei_sync (handle);
 225         if (ret == NULL) {
 226                 dts_fail("tel_get_misc_me_imei_sync", "Unexpected return");
 227         }
 228
 229         dts_pass("tel_get_misc_me_imei_sync");
 230 }
 231
 232 static void utc_fail_tel_get_misc_me_imei_sync (void)
 233 {
 234         char *ret = NULL;
 235
 236         ret = tel_get_misc_me_imei_sync (NULL);
 237         if (ret != NULL) {
 238                 dts_fail("tel_get_misc_me_imei_sync", "Unexpected return");
 239         }
 240
 241         dts_pass("tel_get_misc_me_imei_sync");
 242 }
 243
 244 /**
 245  * tel_check_modem_power_status
 246  *
 247  */
 248 static void utc_tel_check_modem_power_status (void)
 249 {
 250         int ret;
 251         int result;
 252
 253         util_init_loop ();
 254
 255         ret = tel_check_modem_power_status (handle, &result);
 256         if (ret != TAPI_API_SUCCESS) {
 257                 dts_fail("tel_check_modem_power_status", "Unexpected return");
 258         }
 259
 260         dts_pass("tel_check_modem_power_status");
 261 }
 262
 263 static void utc_fail_tel_check_modem_power_status (void)
 264 {
 265         int ret;
 266         int result;
 267
 268         ret = tel_check_modem_power_status (NULL, &result);
 269         if (ret != TAPI_API_SUCCESS) {
 270                 dts_fail("tel_check_modem_power_status", "Unexpected return");
 271         }
 272
 273         ret = tel_check_modem_power_status (handle, NULL);
 274         if (ret != TAPI_API_SUCCESS) {
 275                 dts_fail("tel_check_modem_power_status", "Unexpected return");
 276         }
 277
 278         dts_pass("tel_check_modem_power_status");
 279 }
 280
 281 /**
 282  * tel_control_modem_dun_pin_ctrl
 283  *
 284  */
 285 static void on_tel_control_modem_dun_pin_ctrl (TapiHandle *handle, int result,
 286                 void *data, void *user_data)
 287 {
 288         int *value = user_data;
 289
 290         async_flag = ASYNC_DONE;
 291         util_stop_loop ();
 292
 293         if (*value != 0xC0FFEE) {
 294                 dts_fail("tel_control_modem_dun_pin_ctrl", "Callback userdata crashed");
 295         }
 296 }
 297
 298 static void utc_tel_control_modem_dun_pin_ctrl (void)
 299 {
 300         int ret;
 301         int value = 0xC0FFEE;
 302         tapi_ps_btdun_pincontrol pincontrol;
 303
 304         pincontrol.signal = GPRS_SIGNAL_DCD;
 305         pincontrol.status = GPRS_SIGNAL_STATUS_ON;
 306
 307         util_init_loop ();
 308
 309         async_flag = ASYNC_READY;
 310         ret = tel_control_modem_dun_pin_ctrl (handle, &pincontrol, on_tel_control_modem_dun_pin_ctrl, &value);
 311         if (ret != TAPI_API_SUCCESS) {
 312                 dts_fail("tel_control_modem_dun_pin_ctrl", "Unexpected return");
 313         }
 314
 315         util_start_loop ();
 316         util_free_loop ();
 317
 318         if (async_flag != ASYNC_DONE) {
 319                 dts_fail("tel_control_modem_dun_pin_ctrl", "Callback not invoked");
 320         }
 321
 322         dts_pass("tel_control_modem_dun_pin_ctrl");
 323 }
 324
 325 static void utc_fail_tel_control_modem_dun_pin_ctrl (void)
 326 {
 327         int ret;
 328
 329         ret = tel_control_modem_dun_pin_ctrl (NULL, NULL, NULL, NULL);
 330         if (ret == TAPI_API_SUCCESS) {
 331                 dts_fail("tel_control_modem_dun_pin_ctrl", "Parameter check failed");
 332         }
 333
 334         ret = tel_control_modem_dun_pin_ctrl (handle, NULL, NULL, NULL);
 335         if (ret == TAPI_API_SUCCESS) {
 336                 dts_fail("tel_control_modem_dun_pin_ctrl", "Parameter check failed");
 337         }
 338
 339         dts_pass("tel_control_modem_dun_pin_ctrl");
 340 }
 341
 342 /**
 343  * Generate default TC for no-additional-parameter type API
 344  *
 345  */
 346 DO(tel_get_flight_mode)
 347 DO(tel_get_misc_me_version)
 348 DO(tel_get_misc_me_sn)
 349 DO(tel_get_misc_me_imei)
 350
 351 struct tet_testlist tet_testlist[] = {
 352         /* generated TC */
 353         { utc_tel_get_flight_mode, 1 },
 354         { utc_fail_tel_get_flight_mode, 2 },
 355         { utc_tel_get_misc_me_version, 1 },
 356         { utc_fail_tel_get_misc_me_version, 2 },
 357         { utc_tel_get_misc_me_sn, 1 },
 358         { utc_fail_tel_get_misc_me_sn, 2 },
 359         { utc_tel_get_misc_me_imei, 1 },
 360         { utc_fail_tel_get_misc_me_imei, 2 },
 361         /* custom TC */
 362         { utc_tel_process_power_command, 1 },
 363         { utc_fail_tel_process_power_command, 2 },
 364         { utc_tel_set_flight_mode, 1 },
 365         { utc_fail_tel_set_flight_mode, 2 },
 366         { utc_tel_get_misc_me_version_sync, 1 },////
 367         { utc_fail_tel_get_misc_me_version_sync, 2 },////
 368         { utc_tel_get_misc_me_sn_sync, 1 },////
 369         { utc_fail_tel_get_misc_me_sn_sync, 2 },////
 370         { utc_tel_get_misc_me_imei_sync, 1 },/////////
 371         { utc_fail_tel_get_misc_me_imei_sync, 2 },//////////
 372         { utc_tel_check_modem_power_status, 1 },
 373         { utc_fail_tel_check_modem_power_status, 2 },
 374         { utc_tel_control_modem_dun_pin_ctrl, 1 },
 375         { utc_fail_tel_control_modem_dun_pin_ctrl, 2 },
 376         { NULL, 0 },
 377 };
 378
 379 static void startup (void)
 380 {
 381         /* start of TC */
 382         tet_printf ("\n TC start");
 383
 384         handle = tel_init (NULL);
 385 }
 386
 387 static void cleanup (void)
 388 {
 389         tel_deinit (handle);
 390
 391         /* end of TC */
 392         tet_printf ("\n TC end");
 393 }
 394
 395 void (*tet_startup) (void) = startup;
 396 void (*tet_cleanup) (void) = cleanup;