wearable/TC/testcase/utc_sap.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 <ITapiSap.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_req_sap_connect
  35  *
  36  */
  37 static void on_tel_req_sap_connect (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_req_sap_connect", "Callback userdata crashed");
  47         }
  48 }
  49
  50 static void utc_tel_req_sap_connect (void)
  51 {
  52         int ret;
  53         int value = 0xC0FFEE;
  54         int max_msg_size;
  55
  56         max_msg_size = 255;
  57
  58         util_init_loop ();
  59
  60         async_flag = ASYNC_READY;
  61         ret = tel_req_sap_connect (handle, max_msg_size, on_tel_req_sap_connect, &value);
  62         if (ret != TAPI_API_SUCCESS) {
  63                 dts_fail("tel_req_sap_connect", "Unexpected return");
  64         }
  65
  66         util_start_loop ();
  67         util_free_loop ();
  68
  69         if (async_flag != ASYNC_DONE) {
  70                 dts_fail("tel_req_sap_connect", "Callback not invoked");
  71         }
  72
  73         dts_pass("tel_req_sap_connect");
  74 }
  75
  76 static void utc_fail_tel_req_sap_connect (void)
  77 {
  78         int ret;
  79
  80         ret = tel_req_sap_connect (NULL, 0, NULL, NULL);
  81         if (ret == TAPI_API_SUCCESS) {
  82                 dts_fail("tel_req_sap_connect", "Parameter check failed");
  83         }
  84
  85         dts_pass("tel_req_sap_connect");
  86 }
  87
  88 /**
  89  * tel_req_sap_transfer_apdu
  90  *
  91  */
  92 static void on_tel_req_sap_transfer_apdu (TapiHandle *handle, int result,
  93                 void *data, void *user_data)
  94 {
  95         int *value = user_data;
  96
  97         async_flag = ASYNC_DONE;
  98         util_stop_loop ();
  99
 100         if (*value != 0xC0FFEE) {
 101                 dts_fail("tel_req_sap_transfer_apdu", "Callback userdata crashed");
 102         }
 103 }
 104
 105 static void utc_tel_req_sap_transfer_apdu (void)
 106 {
 107         int ret;
 108         int value = 0xC0FFEE;
 109         TelSapApduData_t apdu;
 110
 111         memset (&apdu, 0, sizeof(TelSimApdu_t));
 112
 113         apdu.apdu_len = 7;
 114         strcpy ((char *)apdu.apdu_data, "a0a40000026f02");
 115
 116         util_init_loop ();
 117
 118         async_flag = ASYNC_READY;
 119         ret = tel_req_sap_transfer_apdu (handle, &apdu, on_tel_req_sap_transfer_apdu, &value);
 120         if (ret != TAPI_API_SUCCESS) {
 121                 dts_fail("tel_req_sap_transfer_apdu", "Unexpected return");
 122         }
 123
 124         util_start_loop ();
 125         util_free_loop ();
 126
 127         if (async_flag != ASYNC_DONE) {
 128                 dts_fail("tel_req_sap_transfer_apdu", "Callback not invoked");
 129         }
 130
 131         dts_pass("tel_req_sap_transfer_apdu");
 132 }
 133
 134 static void utc_fail_tel_req_sap_transfer_apdu (void)
 135 {
 136         int ret;
 137
 138         ret = tel_req_sap_transfer_apdu (NULL, NULL, NULL, NULL);
 139         if (ret == TAPI_API_SUCCESS) {
 140                 dts_fail("tel_req_sap_transfer_apdu", "Parameter check failed");
 141         }
 142
 143         ret = tel_req_sap_transfer_apdu (handle, NULL, NULL, NULL);
 144         if (ret == TAPI_API_SUCCESS) {
 145                 dts_fail("tel_req_sap_transfer_apdu", "Parameter check failed");
 146         }
 147
 148         dts_pass("tel_req_sap_transfer_apdu");
 149 }
 150
 151 /**
 152  * tel_req_sap_transport_protocol
 153  *
 154  */
 155 static void on_tel_req_sap_transport_protocol (TapiHandle *handle, int result,
 156                 void *data, void *user_data)
 157 {
 158         int *value = user_data;
 159
 160         async_flag = ASYNC_DONE;
 161         util_stop_loop ();
 162
 163         if (*value != 0xC0FFEE) {
 164                 dts_fail("tel_req_sap_transport_protocol", "Callback userdata crashed");
 165         }
 166 }
 167
 168 static void utc_tel_req_sap_transport_protocol (void)
 169 {
 170         int ret;
 171         int value = 0xC0FFEE;
 172         TelSimSapProtocol_t protocol;
 173
 174         protocol = 0;
 175
 176         util_init_loop ();
 177
 178         async_flag = ASYNC_READY;
 179         ret = tel_req_sap_transport_protocol (handle, protocol, on_tel_req_sap_transport_protocol, &value);
 180         if (ret != TAPI_API_SUCCESS) {
 181                 dts_fail("tel_req_sap_transport_protocol", "Unexpected return");
 182         }
 183
 184         util_start_loop ();
 185         util_free_loop ();
 186
 187         if (async_flag != ASYNC_DONE) {
 188                 dts_fail("tel_req_sap_transport_protocol", "Callback not invoked");
 189         }
 190
 191         dts_pass("tel_req_sap_transport_protocol");
 192 }
 193
 194 static void utc_fail_tel_req_sap_transport_protocol (void)
 195 {
 196         int ret;
 197
 198         ret = tel_req_sap_transport_protocol (NULL, 0, NULL, NULL);
 199         if (ret == TAPI_API_SUCCESS) {
 200                 dts_fail("tel_req_sap_transport_protocol", "Parameter check failed");
 201         }
 202
 203         dts_pass("tel_req_sap_transport_protocol");
 204 }
 205
 206 /**
 207  * tel_req_sap_power_operation
 208  *
 209  */
 210 static void on_tel_req_sap_power_operation (TapiHandle *handle, int result,
 211                 void *data, void *user_data)
 212 {
 213         int *value = user_data;
 214
 215         async_flag = ASYNC_DONE;
 216         util_stop_loop ();
 217
 218         if (*value != 0xC0FFEE) {
 219                 dts_fail("tel_req_sap_power_operation", "Callback userdata crashed");
 220         }
 221 }
 222
 223 static void utc_tel_req_sap_power_operation (void)
 224 {
 225         int ret;
 226         int value = 0xC0FFEE;
 227         TelSimSapPowerMode_t power_mode;
 228
 229         power_mode = 0;
 230
 231         util_init_loop ();
 232
 233         async_flag = ASYNC_READY;
 234         ret = tel_req_sap_power_operation (handle, power_mode, on_tel_req_sap_power_operation, &value);
 235         if (ret != TAPI_API_SUCCESS) {
 236                 dts_fail("tel_req_sap_power_operation", "Unexpected return");
 237         }
 238
 239         util_start_loop ();
 240         util_free_loop ();
 241
 242         if (async_flag != ASYNC_DONE) {
 243                 dts_fail("tel_req_sap_power_operation", "Callback not invoked");
 244         }
 245
 246         dts_pass("tel_req_sap_power_operation");
 247 }
 248
 249 static void utc_fail_tel_req_sap_power_operation (void)
 250 {
 251         int ret;
 252
 253         ret = tel_req_sap_power_operation (NULL, 0, NULL, NULL);
 254         if (ret == TAPI_API_SUCCESS) {
 255                 dts_fail("tel_req_sap_power_operation", "Parameter check failed");
 256         }
 257
 258         dts_pass("tel_req_sap_power_operation");
 259 }
 260
 261 /**
 262  * Generate default TC for no-additional-parameter type API
 263  *
 264  */
 265 DO(tel_req_sap_disconnect)
 266 DO(tel_req_sap_connection_status)
 267 DO(tel_req_sap_transfer_atr)
 268 DO(tel_req_sap_cardreader_status)
 269
 270 struct tet_testlist tet_testlist[] = {
 271         /* generated TC */
 272         { utc_tel_req_sap_disconnect, 1 },
 273         { utc_fail_tel_req_sap_disconnect, 2 },
 274         { utc_tel_req_sap_connection_status, 1 },
 275         { utc_fail_tel_req_sap_connection_status, 2 },
 276         { utc_tel_req_sap_transfer_atr, 1 },
 277         { utc_fail_tel_req_sap_transfer_atr, 2 },
 278         { utc_tel_req_sap_cardreader_status, 1 },
 279         { utc_fail_tel_req_sap_cardreader_status, 2 },
 280         /* custom TC */
 281         { utc_tel_req_sap_connect, 1 },
 282         { utc_fail_tel_req_sap_connect, 2 },
 283         { utc_tel_req_sap_transfer_apdu, 1 },
 284         { utc_fail_tel_req_sap_transfer_apdu, 2 },
 285         { utc_tel_req_sap_transport_protocol, 1 },
 286         { utc_fail_tel_req_sap_transport_protocol, 2 },
 287         { utc_tel_req_sap_power_operation, 1 },
 288         { utc_fail_tel_req_sap_power_operation, 2 },
 289         { NULL, 0 },
 290 };
 291
 292 static void startup (void)
 293 {
 294         /* start of TC */
 295         tet_printf ("\n TC start");
 296
 297         handle = tel_init (NULL);
 298 }
 299
 300 static void cleanup (void)
 301 {
 302         tel_deinit (handle);
 303
 304         /* end of TC */
 305         tet_printf ("\n TC end");
 306 }
 307
 308 void (*tet_startup) (void) = startup;
 309 void (*tet_cleanup) (void) = cleanup;