wearable/TC/testcase/utc_gps.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 <ITapiGps.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_set_gps_frequency_aiding
  35  *
  36  */
  37 static void on_tel_set_gps_frequency_aiding (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_set_gps_frequency_aiding", "Callback userdata crashed");
  47         }
  48 }
  49
  50 static void utc_tel_set_gps_frequency_aiding (void)
  51 {
  52         int ret;
  53         int value = 0xC0FFEE;
  54         unsigned char state = 'a';
  55
  56         util_init_loop ();
  57
  58         async_flag = ASYNC_READY;
  59         ret = tel_set_gps_frequency_aiding (handle, state, on_tel_set_gps_frequency_aiding, &value);
  60         if (ret != TAPI_API_SUCCESS) {
  61                 dts_fail("tel_set_gps_frequency_aiding", "Unexpected return");
  62         }
  63
  64         util_start_loop ();
  65         util_free_loop ();
  66
  67         if (async_flag != ASYNC_DONE) {
  68                 dts_fail("tel_set_gps_frequency_aiding", "Callback not invoked");
  69         }
  70
  71         dts_pass("tel_set_gps_frequency_aiding");
  72 }
  73
  74 static void utc_fail_tel_set_gps_frequency_aiding (void)
  75 {
  76         int ret;
  77         unsigned char state = 'a';
  78
  79         ret = tel_set_gps_frequency_aiding (NULL, state, NULL, NULL);
  80         if (ret == TAPI_API_SUCCESS) {
  81                 dts_fail("tel_set_gps_frequency_aiding", "Parameter check failed");
  82         }
  83
  84         dts_pass("tel_set_gps_frequency_aiding");
  85 }
  86
  87 /**
  88  * tel_confirm_gps_measure_pos
  89  *
  90  */
  91 static void utc_tel_confirm_gps_measure_pos (void)
  92 {
  93         int ret;
  94
  95         util_init_loop ();
  96
  97         ret = tel_confirm_gps_measure_pos (handle, (unsigned char *)"abc1234", 7);
  98         if (ret != TAPI_API_SUCCESS) {
  99                 dts_fail("tel_confirm_gps_measure_pos", "Unexpected return");
 100         }
 101
 102         dts_pass("tel_confirm_gps_measure_pos");
 103 }
 104
 105 static void utc_fail_tel_confirm_gps_measure_pos (void)
 106 {
 107         int ret;
 108
 109         ret = tel_confirm_gps_measure_pos (NULL, (unsigned char *)"abc1234", 7);
 110         if (ret == TAPI_API_SUCCESS) {
 111                 dts_fail("tel_confirm_gps_measure_pos", "Parameter check failed");
 112         }
 113
 114         ret = tel_confirm_gps_measure_pos (handle, NULL, 7);
 115         if (ret == TAPI_API_SUCCESS) {
 116                 dts_fail("tel_confirm_gps_measure_pos", "Parameter check failed");
 117         }
 118
 119         dts_pass("tel_confirm_gps_measure_pos");
 120 }
 121
 122 /**
 123  * tel_sync_smart_assistant_area_list
 124  *
 125  */
 126 static void on_tel_sync_smart_assistant_area_list (TapiHandle *handle, int result,
 127                 void *data, void *user_data)
 128 {
 129         int *value = user_data;
 130
 131         async_flag = ASYNC_DONE;
 132         util_stop_loop ();
 133
 134         if (*value != 0xC0FFEE) {
 135                 dts_fail("tel_sync_smart_assistant_area_list", "Callback userdata crashed");
 136         }
 137 }
 138
 139 static void utc_tel_sync_smart_assistant_area_list (void)
 140 {
 141         int ret;
 142         int value = 0xC0FFEE;
 143         TelSmartAssistantAreaList_t area_list;
 144
 145         memset (&area_list, 0, sizeof(TelSmartAssistantAreaList_t));
 146
 147         area_list.count = 1;
 148         area_list.area->index = 1;
 149         area_list.area->mode_state = TAPI_SMART_ASSISTANT_MODE_STATE_START;
 150
 151         util_init_loop ();
 152
 153         async_flag = ASYNC_READY;
 154         ret = tel_sync_smart_assistant_area_list (handle, &area_list, on_tel_sync_smart_assistant_area_list, &value);
 155         if (ret != TAPI_API_SUCCESS) {
 156                 dts_fail("tel_sync_smart_assistant_area_list", "Unexpected return");
 157         }
 158
 159         util_start_loop ();
 160         util_free_loop ();
 161
 162         if (async_flag != ASYNC_DONE) {
 163                 dts_fail("tel_sync_smart_assistant_area_list", "Callback not invoked");
 164         }
 165
 166         dts_pass("tel_sync_smart_assistant_area_list");
 167 }
 168
 169 static void utc_fail_tel_sync_smart_assistant_area_list (void)
 170 {
 171         int ret;
 172         TelSmartAssistantAreaList_t area_list;
 173
 174         memset (&area_list, 0, sizeof(TelSmartAssistantAreaList_t));
 175
 176         area_list.count = 1;
 177         area_list.area->index = 1;
 178         area_list.area->mode_state = TAPI_SMART_ASSISTANT_MODE_STATE_START;
 179
 180         ret = tel_sync_smart_assistant_area_list (NULL, &area_list, NULL, NULL);
 181         if (ret == TAPI_API_SUCCESS) {
 182                 dts_fail("tel_sync_smart_assistant_area_list", "Parameter check failed");
 183         }
 184
 185         ret = tel_sync_smart_assistant_area_list (handle, NULL, NULL, NULL);
 186         if (ret == TAPI_API_SUCCESS) {
 187                 dts_fail("tel_sync_smart_assistant_area_list", "Parameter check failed");
 188         }
 189
 190         dts_pass("tel_sync_smart_assistant_area_list");
 191 }
 192
 193 /**
 194  * tel_del_smart_assistant_area_list
 195  *
 196  */
 197 static void on_tel_del_smart_assistant_area_list (TapiHandle *handle, int result,
 198                 void *data, void *user_data)
 199 {
 200         int *value = user_data;
 201
 202         async_flag = ASYNC_DONE;
 203         util_stop_loop ();
 204
 205         if (*value != 0xC0FFEE) {
 206                 dts_fail("tel_del_smart_assistant_area_list", "Callback userdata crashed");
 207         }
 208 }
 209
 210 static void utc_tel_del_smart_assistant_area_list (void)
 211 {
 212         int ret;
 213         int value = 0xC0FFEE;
 214         TelSmartAssistantAreaList_t area_list;
 215
 216         memset (&area_list, 0, sizeof(TelSmartAssistantAreaList_t));
 217
 218         area_list.count = 1;
 219         area_list.area->index = 1;
 220         area_list.area->mode_state = TAPI_SMART_ASSISTANT_MODE_STATE_STOP;
 221
 222         util_init_loop ();
 223
 224         async_flag = ASYNC_READY;
 225         ret = tel_del_smart_assistant_area_list (handle, &area_list, on_tel_del_smart_assistant_area_list, &value);
 226         if (ret != TAPI_API_SUCCESS) {
 227                 dts_fail("tel_del_smart_assistant_area_list", "Unexpected return");
 228         }
 229
 230         util_start_loop ();
 231         util_free_loop ();
 232
 233         if (async_flag != ASYNC_DONE) {
 234                 dts_fail("tel_del_smart_assistant_area_list", "Callback not invoked");
 235         }
 236
 237         dts_pass("tel_del_smart_assistant_area_list");
 238 }
 239
 240 static void utc_fail_tel_del_smart_assistant_area_list (void)
 241 {
 242         int ret;
 243         TelSmartAssistantAreaList_t area_list;
 244
 245         memset (&area_list, 0, sizeof(TelSmartAssistantAreaList_t));
 246
 247         area_list.count = 1;
 248         area_list.area->index = 1;
 249         area_list.area->mode_state = TAPI_SMART_ASSISTANT_MODE_STATE_STOP;
 250
 251         ret = tel_del_smart_assistant_area_list (NULL, &area_list, NULL, NULL);
 252         if (ret == TAPI_API_SUCCESS) {
 253                 dts_fail("tel_del_smart_assistant_area_list", "Parameter check failed");
 254         }
 255
 256         ret = tel_del_smart_assistant_area_list (handle, NULL, NULL, NULL);
 257         if (ret == TAPI_API_SUCCESS) {
 258                 dts_fail("tel_del_smart_assistant_area_list", "Parameter check failed");
 259         }
 260
 261         dts_pass("tel_del_smart_assistant_area_list");
 262 }
 263
 264 /**
 265  * tel_add_smart_assistant_area
 266  *
 267  */
 268 static void on_tel_add_smart_assistant_area (TapiHandle *handle, int result,
 269                 void *data, void *user_data)
 270 {
 271         int *value = user_data;
 272
 273         async_flag = ASYNC_DONE;
 274         util_stop_loop ();
 275
 276         if (*value != 0xC0FFEE) {
 277                 dts_fail("tel_add_smart_assistant_area", "Callback userdata crashed");
 278         }
 279 }
 280
 281 static void utc_tel_add_smart_assistant_area (void)
 282 {
 283         int ret;
 284         int value = 0xC0FFEE;
 285         TelSmartAssistantArea_t area;
 286
 287         memset (&area, 0, sizeof(TelSmartAssistantArea_t));
 288
 289         area.index = 1;
 290         area.mode_state = TAPI_SMART_ASSISTANT_MODE_STATE_STOP;
 291
 292         util_init_loop ();
 293
 294         async_flag = ASYNC_READY;
 295         ret = tel_add_smart_assistant_area (handle, &area, on_tel_add_smart_assistant_area, &value);
 296         if (ret != TAPI_API_SUCCESS) {
 297                 dts_fail("tel_add_smart_assistant_area", "Unexpected return");
 298         }
 299
 300         util_start_loop ();
 301         util_free_loop ();
 302
 303         if (async_flag != ASYNC_DONE) {
 304                 dts_fail("tel_add_smart_assistant_area", "Callback not invoked");
 305         }
 306
 307         dts_pass("tel_add_smart_assistant_area");
 308 }
 309
 310 static void utc_fail_tel_add_smart_assistant_area (void)
 311 {
 312         int ret;
 313         TelSmartAssistantArea_t area;
 314
 315         memset (&area, 0, sizeof(TelSmartAssistantArea_t));
 316
 317         area.index = 1;
 318         area.mode_state = TAPI_SMART_ASSISTANT_MODE_STATE_STOP;
 319
 320         ret = tel_add_smart_assistant_area (NULL, &area, NULL, NULL);
 321         if (ret == TAPI_API_SUCCESS) {
 322                 dts_fail("tel_add_smart_assistant_area", "Parameter check failed");
 323         }
 324
 325         ret = tel_add_smart_assistant_area (handle, NULL, NULL, NULL);
 326         if (ret == TAPI_API_SUCCESS) {
 327                 dts_fail("tel_add_smart_assistant_area", "Parameter check failed");
 328         }
 329
 330         dts_pass("tel_add_smart_assistant_area");
 331 }
 332
 333 /**
 334  * tel_modify_smart_assistant_area
 335  *
 336  */
 337 static void on_tel_modify_smart_assistant_area (TapiHandle *handle, int result,
 338                 void *data, void *user_data)
 339 {
 340         int *value = user_data;
 341
 342         async_flag = ASYNC_DONE;
 343         util_stop_loop ();
 344
 345         if (*value != 0xC0FFEE) {
 346                 dts_fail("tel_modify_smart_assistant_area", "Callback userdata crashed");
 347         }
 348 }
 349
 350 static void utc_tel_modify_smart_assistant_area (void)
 351 {
 352         int ret;
 353         int value = 0xC0FFEE;
 354         TelSmartAssistantArea_t area;
 355
 356         memset (&area, 0, sizeof(TelSmartAssistantArea_t));
 357
 358         area.index = 1;
 359         area.mode_state = TAPI_SMART_ASSISTANT_MODE_STATE_START;
 360
 361         util_init_loop ();
 362
 363         async_flag = ASYNC_READY;
 364         ret = tel_modify_smart_assistant_area (handle, &area, on_tel_modify_smart_assistant_area, &value);
 365         if (ret != TAPI_API_SUCCESS) {
 366                 dts_fail("tel_modify_smart_assistant_area", "Unexpected return");
 367         }
 368
 369         util_start_loop ();
 370         util_free_loop ();
 371
 372         if (async_flag != ASYNC_DONE) {
 373                 dts_fail("tel_modify_smart_assistant_area", "Callback not invoked");
 374         }
 375
 376         dts_pass("tel_modify_smart_assistant_area");
 377 }
 378
 379 static void utc_fail_tel_modify_smart_assistant_area (void)
 380 {
 381         int ret;
 382         TelSmartAssistantArea_t area;
 383
 384         memset (&area, 0, sizeof(TelSmartAssistantArea_t));
 385
 386         area.index = 1;
 387         area.mode_state = TAPI_SMART_ASSISTANT_MODE_STATE_START;
 388
 389         ret = tel_modify_smart_assistant_area (NULL, &area, NULL, NULL);
 390         if (ret == TAPI_API_SUCCESS) {
 391                 dts_fail("tel_modify_smart_assistant_area", "Parameter check failed");
 392         }
 393
 394         ret = tel_modify_smart_assistant_area (handle, NULL, NULL, NULL);
 395         if (ret == TAPI_API_SUCCESS) {
 396                 dts_fail("tel_modify_smart_assistant_area", "Parameter check failed");
 397         }
 398
 399         dts_pass("tel_modify_smart_assistant_area");
 400 }
 401
 402 /**
 403  * tel_set_smart_assistant_info
 404  *
 405  */
 406 static void on_tel_set_smart_assistant_info (TapiHandle *handle, int result,
 407                 void *data, void *user_data)
 408 {
 409         int *value = user_data;
 410
 411         async_flag = ASYNC_DONE;
 412         util_stop_loop ();
 413
 414         if (*value != 0xC0FFEE) {
 415                 dts_fail("tel_set_smart_assistant_info", "Callback userdata crashed");
 416         }
 417 }
 418
 419 static void utc_tel_set_smart_assistant_info (void)
 420 {
 421         int ret;
 422         int value = 0xC0FFEE;
 423         TelSmartAssistantInfo_t info;
 424
 425         memset (&info, 0, sizeof(TelSmartAssistantInfo_t));
 426
 427         info.index = 1;
 428         info.lpp_state = TAPI_SMART_ASSISTANT_LPP_STATE_START;
 429
 430         util_init_loop ();
 431
 432         async_flag = ASYNC_READY;
 433         ret = tel_set_smart_assistant_info (handle, &info, on_tel_set_smart_assistant_info, &value);
 434         if (ret != TAPI_API_SUCCESS) {
 435                 dts_fail("tel_set_smart_assistant_info", "Unexpected return");
 436         }
 437
 438         util_start_loop ();
 439         util_free_loop ();
 440
 441         if (async_flag != ASYNC_DONE) {
 442                 dts_fail("tel_set_smart_assistant_info", "Callback not invoked");
 443         }
 444
 445         dts_pass("tel_set_smart_assistant_info");
 446 }
 447
 448 static void utc_fail_tel_set_smart_assistant_info (void)
 449 {
 450         int ret;
 451         TelSmartAssistantInfo_t info;
 452
 453         memset (&info, 0, sizeof(TelSmartAssistantInfo_t));
 454
 455         info.index = 1;
 456         info.lpp_state = TAPI_SMART_ASSISTANT_MODE_STATE_START;
 457
 458         ret = tel_set_smart_assistant_info (NULL, &info, NULL, NULL);
 459         if (ret == TAPI_API_SUCCESS) {
 460                 dts_fail("tel_set_smart_assistant_info", "Parameter check failed");
 461         }
 462
 463         ret = tel_set_smart_assistant_info (handle, NULL, NULL, NULL);
 464         if (ret == TAPI_API_SUCCESS) {
 465                 dts_fail("tel_set_smart_assistant_info", "Parameter check failed");
 466         }
 467
 468         dts_pass("tel_set_smart_assistant_info");
 469 }
 470
 471 /**
 472  * Generate default TC for no-additional-parameter type API
 473  *
 474  */
 475 DO(tel_enable_smart_assistant)
 476 DO(tel_disable_smart_assistant)
 477
 478 struct tet_testlist tet_testlist[] = {
 479         /* generated TC */
 480         { utc_tel_enable_smart_assistant, 1 },
 481         { utc_fail_tel_enable_smart_assistant, 2 },
 482         { utc_tel_disable_smart_assistant, 1 },
 483         { utc_fail_tel_disable_smart_assistant, 2 },
 484         /* custom TC */
 485         { utc_tel_set_gps_frequency_aiding, 1 },
 486         { utc_fail_tel_set_gps_frequency_aiding, 2 },
 487         { utc_tel_confirm_gps_measure_pos, 1 },
 488         { utc_fail_tel_confirm_gps_measure_pos, 2 },
 489         { utc_tel_sync_smart_assistant_area_list, 1 },
 490         { utc_fail_tel_sync_smart_assistant_area_list, 2 },
 491         { utc_tel_del_smart_assistant_area_list, 1 },
 492         { utc_fail_tel_del_smart_assistant_area_list, 2 },
 493         { utc_tel_add_smart_assistant_area, 1 },
 494         { utc_fail_tel_add_smart_assistant_area, 2 },
 495         { utc_tel_modify_smart_assistant_area, 1 },
 496         { utc_fail_tel_modify_smart_assistant_area, 2 },
 497         { utc_tel_set_smart_assistant_info, 1 },
 498         { utc_fail_tel_set_smart_assistant_info, 2 },
 499         { NULL, 0 },
 500 };
 501
 502 static void startup (void)
 503 {
 504         /* start of TC */
 505         tet_printf ("\n TC start");
 506
 507         handle = tel_init (NULL);
 508 }
 509
 510 static void cleanup (void)
 511 {
 512         tel_deinit (handle);
 513
 514         /* end of TC */
 515         tet_printf ("\n TC end");
 516 }
 517
 518 void (*tet_startup) (void) = startup;
 519 void (*tet_cleanup) (void) = cleanup;