wearable/TC/testcase/utc_network.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 <ITapiNetwork.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_select_network_manual
  35  *
  36  */
  37 static void on_tel_select_network_manual (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_select_network_manual", "Callback userdata crashed");
  47         }
  48 }
  49
  50 static void utc_tel_select_network_manual (void)
  51 {
  52         int ret;
  53         int value = 0xC0FFEE;
  54
  55         util_init_loop ();
  56
  57         async_flag = ASYNC_READY;
  58         ret = tel_select_network_manual (handle, "45001", TAPI_NETWORK_SYSTEM_LTE,
  59                         on_tel_select_network_manual, &value);
  60         if (ret != TAPI_API_SUCCESS) {
  61                 dts_fail("tel_select_network_manual", "Unexpected return");
  62         }
  63
  64         util_start_loop ();
  65         util_free_loop ();
  66
  67         if (async_flag != ASYNC_DONE) {
  68                 dts_fail("tel_select_network_manual", "Callback not invoked");
  69         }
  70
  71         dts_pass("tel_select_network_manual");
  72 }
  73
  74 static void utc_fail_tel_select_network_manual (void)
  75 {
  76         int ret;
  77
  78         ret = tel_select_network_manual (NULL, NULL, 0, NULL, NULL);
  79         if (ret == TAPI_API_SUCCESS) {
  80                 dts_fail("tel_select_network_manual", "Parameter check failed");
  81         }
  82
  83         ret = tel_select_network_manual (handle, NULL, 0, NULL, NULL);
  84         if (ret == TAPI_API_SUCCESS) {
  85                 dts_fail("tel_select_network_manual", "Parameter check failed");
  86         }
  87
  88         dts_pass("tel_select_network_manual");
  89 }
  90
  91 /**
  92  * tel_set_network_band
  93  *
  94  */
  95 static void on_tel_set_network_band (TapiHandle *handle, int result, void *data,
  96                 void *user_data)
  97 {
  98         int *value = user_data;
  99
 100         async_flag = ASYNC_DONE;
 101         util_stop_loop ();
 102
 103         if (*value != 0xC0FFEE) {
 104                 dts_fail("tel_set_network_band", "Callback userdata crashed");
 105         }
 106 }
 107
 108 static void utc_tel_set_network_band (void)
 109 {
 110         int ret;
 111         int value = 0xC0FFEE;
 112
 113         util_init_loop ();
 114
 115         async_flag = ASYNC_READY;
 116         ret = tel_set_network_band (handle, TAPI_NETWORK_BAND_MODE_ONLY,
 117                         TAPI_NETWORK_BAND_TYPE_ANY, on_tel_set_network_band, &value);
 118         if (ret != TAPI_API_SUCCESS) {
 119                 dts_fail("tel_set_network_band", "Unexpected return");
 120         }
 121
 122         util_start_loop ();
 123         util_free_loop ();
 124
 125         if (async_flag != ASYNC_DONE) {
 126                 dts_fail("tel_set_network_band", "Callback not invoked");
 127         }
 128
 129         dts_pass("tel_set_network_band");
 130 }
 131
 132 static void utc_fail_tel_set_network_band (void)
 133 {
 134         int ret;
 135
 136         ret = tel_set_network_band (NULL, 0, 0, NULL, NULL);
 137         if (ret == TAPI_API_SUCCESS) {
 138                 dts_fail("tel_set_network_band", "Parameter check failed");
 139         }
 140
 141         dts_pass("tel_set_network_band");
 142 }
 143
 144 /**
 145  * tel_set_network_mode
 146  *
 147  */
 148 static void on_tel_set_network_mode (TapiHandle *handle, int result, void *data,
 149                 void *user_data)
 150 {
 151         int *value = user_data;
 152
 153         async_flag = ASYNC_DONE;
 154         util_stop_loop ();
 155
 156         if (*value != 0xC0FFEE) {
 157                 dts_fail("tel_set_network_mode", "Callback userdata crashed");
 158         }
 159 }
 160
 161 static void utc_tel_set_network_mode (void)
 162 {
 163         int ret;
 164         int value = 0xC0FFEE;
 165
 166         util_init_loop ();
 167
 168         async_flag = ASYNC_READY;
 169         ret = tel_set_network_mode (handle, TAPI_NETWORK_MODE_AUTO,
 170                         on_tel_set_network_mode, &value);
 171         if (ret != TAPI_API_SUCCESS) {
 172                 dts_fail("tel_set_network_mode", "Unexpected return");
 173         }
 174
 175         util_start_loop ();
 176         util_free_loop ();
 177
 178         if (async_flag != ASYNC_DONE) {
 179                 dts_fail("tel_set_network_mode", "Callback not invoked");
 180         }
 181
 182         dts_pass("tel_set_network_mode");
 183 }
 184
 185 static void utc_fail_tel_set_network_mode (void)
 186 {
 187         int ret;
 188
 189         ret = tel_set_network_mode (NULL, 0, NULL, NULL);
 190         if (ret == TAPI_API_SUCCESS) {
 191                 dts_fail("tel_set_network_mode", "Parameter check failed");
 192         }
 193
 194         dts_pass("tel_set_network_mode");
 195 }
 196
 197 /**
 198  * tel_set_network_preferred_plmn
 199  *
 200  */
 201 static void on_tel_set_network_preferred_plmn (TapiHandle *handle, int result,
 202                 void *data, void *user_data)
 203 {
 204         int *value = user_data;
 205
 206         async_flag = ASYNC_DONE;
 207         util_stop_loop ();
 208
 209         if (*value != 0xC0FFEE) {
 210                 dts_fail("tel_set_network_preferred_plmn", "Callback userdata crashed");
 211         }
 212 }
 213
 214 static void utc_tel_set_network_preferred_plmn (void)
 215 {
 216         int ret;
 217         int value = 0xC0FFEE;
 218         TelNetworkPreferredPlmnInfo_t info;
 219
 220         memset (&info, 0, sizeof(TelNetworkPreferredPlmnInfo_t));
 221         info.SystemType = TAPI_NETWORK_SYSTEM_GSM;
 222         info.Index = 1;
 223         strncpy (info.Plmn, TAPI_NETWORK_PLMN_LEN_MAX, "45001");
 224
 225         util_init_loop ();
 226
 227         async_flag = ASYNC_READY;
 228         ret = tel_set_network_preferred_plmn (handle, TAPI_NETWORK_PREF_PLMN_ADD,
 229                         &info, on_tel_set_network_preferred_plmn, &value);
 230         if (ret != TAPI_API_SUCCESS) {
 231                 dts_fail("tel_set_network_preferred_plmn", "Unexpected return");
 232         }
 233
 234         util_start_loop ();
 235         util_free_loop ();
 236
 237         if (async_flag != ASYNC_DONE) {
 238                 dts_fail("tel_set_network_preferred_plmn", "Callback not invoked");
 239         }
 240
 241         dts_pass("tel_set_network_preferred_plmn");
 242 }
 243
 244 static void utc_fail_tel_set_network_preferred_plmn (void)
 245 {
 246         int ret;
 247
 248         ret = tel_set_network_preferred_plmn (NULL, 0, NULL, NULL, NULL);
 249         if (ret == TAPI_API_SUCCESS) {
 250                 dts_fail("tel_set_network_preferred_plmn", "Parameter check failed");
 251         }
 252
 253         dts_pass("tel_set_network_preferred_plmn");
 254 }
 255
 256 /**
 257  * tel_set_network_service_domain
 258  *
 259  */
 260 static void on_tel_set_network_service_domain (TapiHandle *handle, int result,
 261                 void *data, void *user_data)
 262 {
 263         int *value = user_data;
 264
 265         async_flag = ASYNC_DONE;
 266         util_stop_loop ();
 267
 268         if (*value != 0xC0FFEE) {
 269                 dts_fail("tel_set_network_service_domain", "Callback userdata crashed");
 270         }
 271 }
 272
 273 static void utc_tel_set_network_service_domain (void)
 274 {
 275         int ret;
 276         int value = 0xC0FFEE;
 277
 278         util_init_loop ();
 279
 280         async_flag = ASYNC_READY;
 281         ret = tel_set_network_service_domain (handle,
 282                         TAPI_NETWORK_SERVICE_DOMAIN_COMBINED,
 283                         on_tel_set_network_service_domain, &value);
 284         if (ret != TAPI_API_SUCCESS) {
 285                 dts_fail("tel_set_network_service_domain", "Unexpected return");
 286         }
 287
 288         util_start_loop ();
 289         util_free_loop ();
 290
 291         if (async_flag != ASYNC_DONE) {
 292                 dts_fail("tel_set_network_service_domain", "Callback not invoked");
 293         }
 294
 295         dts_pass("tel_set_network_service_domain");
 296 }
 297
 298 static void utc_fail_tel_set_network_service_domain (void)
 299 {
 300         int ret;
 301
 302         ret = tel_set_network_service_domain (NULL, 0, NULL, NULL);
 303         if (ret == TAPI_API_SUCCESS) {
 304                 dts_fail("tel_set_network_service_domain", "Parameter check failed");
 305         }
 306
 307         dts_pass("tel_set_network_service_domain");
 308 }
 309
 310
 311 /**
 312  * Generate default TC for no-additional-parameter type API
 313  *
 314  */
 315 DO(tel_search_network)
 316 DO(tel_cancel_network_manual_search)
 317 DO(tel_get_network_band)
 318 DO(tel_get_network_mode)
 319 DO(tel_get_network_neighboring_cell_info)
 320 DO(tel_get_network_preferred_plmn)
 321 DO(tel_get_network_selection_mode)
 322 DO(tel_get_network_service_domain)
 323 DO(tel_get_network_serving)
 324 DO(tel_select_network_automatic)
 325
 326 struct tet_testlist tet_testlist[] = {
 327         /* generated TC */
 328 //      { utc_tel_search_network, 1 },
 329 //      { utc_fail_tel_search_network, 2 },
 330         { utc_tel_cancel_network_manual_search, 1 },
 331         { utc_fail_tel_cancel_network_manual_search, 2 },
 332         { utc_tel_get_network_band, 1 },
 333         { utc_fail_tel_get_network_band, 2 },
 334         { utc_tel_get_network_mode, 1 },
 335         { utc_fail_tel_get_network_mode, 2 },
 336         { utc_tel_get_network_neighboring_cell_info, 1 },
 337         { utc_fail_tel_get_network_neighboring_cell_info, 2 },
 338         { utc_tel_get_network_preferred_plmn, 1 },
 339         { utc_fail_tel_get_network_preferred_plmn, 2 },
 340         { utc_tel_get_network_selection_mode, 1 },
 341         { utc_fail_tel_get_network_selection_mode, 2 },
 342         { utc_tel_get_network_service_domain, 1 },
 343         { utc_fail_tel_get_network_service_domain, 2 },
 344         { utc_tel_get_network_serving, 1 },
 345         { utc_fail_tel_get_network_serving, 2 },
 346         { utc_tel_select_network_automatic, 1 },
 347         { utc_fail_tel_select_network_automatic, 2 },
 348
 349         /* custom TC */
 350         { utc_tel_select_network_manual, 1 },
 351         { utc_fail_tel_select_network_manual, 2 },
 352         { utc_tel_set_network_band, 1 },
 353         { utc_fail_tel_set_network_band, 2 },
 354         { utc_tel_set_network_mode, 1 },
 355         { utc_fail_tel_set_network_mode, 2 },
 356         { utc_tel_set_network_preferred_plmn, 1 },
 357         { utc_fail_tel_set_network_preferred_plmn, 2 },
 358         { utc_tel_set_network_service_domain, 1 },
 359         { utc_fail_tel_set_network_service_domain, 2 },
 360         { NULL, 0 },
 361 };
 362
 363 static void startup (void)
 364 {
 365         /* start of TC */
 366         tet_printf ("\n TC start");
 367
 368         handle = tel_init (NULL);
 369 }
 370
 371 static void cleanup (void)
 372 {
 373         tel_deinit (handle);
 374
 375         /* end of TC */
 376         tet_printf ("\n TC end");
 377 }
 378
 379 void (*tet_startup) (void) = startup;
 380 void (*tet_cleanup) (void) = cleanup;