TC/testcase/utc_runtime_info.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <tet_api.h>
  18 #include <runtime_info.h>
  19
  20 static void startup(void);
  21 static void cleanup(void);
  22
  23 void (*tet_startup)(void) = startup;
  24 void (*tet_cleanup)(void) = cleanup;
  25
  26 static void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative1(void);
  27 static void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative2(void);
  28 static void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative3(void);
  29 static void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive1(void);
  30 static void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive2(void);
  31 static void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive3(void);
  32 static void utc_runtime_info_AUDIO_JACK_CONNECTED_negative1(void);
  33 static void utc_runtime_info_AUDIO_JACK_CONNECTED_negative2(void);
  34 static void utc_runtime_info_AUDIO_JACK_CONNECTED_negative3(void);
  35 static void utc_runtime_info_AUDIO_JACK_CONNECTED_positive1(void);
  36 static void utc_runtime_info_AUDIO_JACK_CONNECTED_positive2(void);
  37 static void utc_runtime_info_AUDIO_JACK_CONNECTED_positive3(void);
  38 static void utc_runtime_info_BATTERY_IS_CHARGING_negative1(void);
  39 static void utc_runtime_info_BATTERY_IS_CHARGING_negative2(void);
  40 static void utc_runtime_info_BATTERY_IS_CHARGING_negative3(void);
  41 static void utc_runtime_info_BATTERY_IS_CHARGING_positive1(void);
  42 static void utc_runtime_info_BATTERY_IS_CHARGING_positive2(void);
  43 static void utc_runtime_info_BATTERY_IS_CHARGING_positive3(void);
  44 static void utc_runtime_info_BLUETOOTH_ENABLED_negative1(void);
  45 static void utc_runtime_info_BLUETOOTH_ENABLED_negative2(void);
  46 static void utc_runtime_info_BLUETOOTH_ENABLED_negative3(void);
  47 static void utc_runtime_info_BLUETOOTH_ENABLED_positive1(void);
  48 static void utc_runtime_info_BLUETOOTH_ENABLED_positive2(void);
  49 static void utc_runtime_info_BLUETOOTH_ENABLED_positive3(void);
  50 static void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative1(void);
  51 static void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative2(void);
  52 static void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative3(void);
  53 static void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive1(void);
  54 static void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive2(void);
  55 static void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive3(void);
  56 static void utc_runtime_info_DATA_ROAMING_ENABLED_negative1(void);
  57 static void utc_runtime_info_DATA_ROAMING_ENABLED_negative2(void);
  58 static void utc_runtime_info_DATA_ROAMING_ENABLED_negative3(void);
  59 static void utc_runtime_info_DATA_ROAMING_ENABLED_positive1(void);
  60 static void utc_runtime_info_DATA_ROAMING_ENABLED_positive2(void);
  61 static void utc_runtime_info_DATA_ROAMING_ENABLED_positive3(void);
  62 static void utc_runtime_info_FIRST_DAY_OF_WEEK_negative1(void);
  63 static void utc_runtime_info_FIRST_DAY_OF_WEEK_negative2(void);
  64 static void utc_runtime_info_FIRST_DAY_OF_WEEK_negative3(void);
  65 static void utc_runtime_info_FIRST_DAY_OF_WEEK_positive1(void);
  66 static void utc_runtime_info_FIRST_DAY_OF_WEEK_positive2(void);
  67 static void utc_runtime_info_FIRST_DAY_OF_WEEK_positive3(void);
  68 static void utc_runtime_info_FLIGHT_MODE_ENABLED_negative1(void);
  69 static void utc_runtime_info_FLIGHT_MODE_ENABLED_negative2(void);
  70 static void utc_runtime_info_FLIGHT_MODE_ENABLED_negative3(void);
  71 static void utc_runtime_info_FLIGHT_MODE_ENABLED_positive1(void);
  72 static void utc_runtime_info_FLIGHT_MODE_ENABLED_positive2(void);
  73 static void utc_runtime_info_FLIGHT_MODE_ENABLED_positive3(void);
  74 static void utc_runtime_info_GPS_STATUS_negative1(void);
  75 static void utc_runtime_info_GPS_STATUS_negative2(void);
  76 static void utc_runtime_info_GPS_STATUS_negative3(void);
  77 static void utc_runtime_info_GPS_STATUS_positive1(void);
  78 static void utc_runtime_info_GPS_STATUS_positive2(void);
  79 static void utc_runtime_info_GPS_STATUS_positive3(void);
  80 static void utc_runtime_info_LANGUAGE_negative1(void);
  81 static void utc_runtime_info_LANGUAGE_negative2(void);
  82 static void utc_runtime_info_LANGUAGE_negative3(void);
  83 static void utc_runtime_info_LANGUAGE_positive1(void);
  84 static void utc_runtime_info_LANGUAGE_positive2(void);
  85 static void utc_runtime_info_LANGUAGE_positive3(void);
  86 static void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative1(void);
  87 static void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative2(void);
  88 static void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative3(void);
  89 static void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive1(void);
  90 static void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive2(void);
  91 static void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive3(void);
  92 static void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative1(void);
  93 static void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative2(void);
  94 static void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative3(void);
  95 static void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive1(void);
  96 static void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive2(void);
  97 static void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive3(void);
  98 static void utc_runtime_info_LOCATION_SERVICE_ENABLED_negative1(void);
  99 static void utc_runtime_info_LOCATION_SERVICE_ENABLED_negative2(void);
 100 static void utc_runtime_info_LOCATION_SERVICE_ENABLED_negative3(void);
 101 static void utc_runtime_info_LOCATION_SERVICE_ENABLED_positive1(void);
 102 static void utc_runtime_info_LOCATION_SERVICE_ENABLED_positive2(void);
 103 static void utc_runtime_info_LOCATION_SERVICE_ENABLED_positive3(void);
 104 static void utc_runtime_info_PACKET_DATA_ENABLED_negative1(void);
 105 static void utc_runtime_info_PACKET_DATA_ENABLED_negative2(void);
 106 static void utc_runtime_info_PACKET_DATA_ENABLED_negative3(void);
 107 static void utc_runtime_info_PACKET_DATA_ENABLED_positive1(void);
 108 static void utc_runtime_info_PACKET_DATA_ENABLED_positive2(void);
 109 static void utc_runtime_info_PACKET_DATA_ENABLED_positive3(void);
 110 static void utc_runtime_info_REGION_negative1(void);
 111 static void utc_runtime_info_REGION_negative2(void);
 112 static void utc_runtime_info_REGION_negative3(void);
 113 static void utc_runtime_info_REGION_positive1(void);
 114 static void utc_runtime_info_REGION_positive2(void);
 115 static void utc_runtime_info_REGION_positive3(void);
 116 static void utc_runtime_info_AUTO_ROTATION_ENABLED_negative1(void);
 117 static void utc_runtime_info_AUTO_ROTATION_ENABLED_negative2(void);
 118 static void utc_runtime_info_AUTO_ROTATION_ENABLED_negative3(void);
 119 static void utc_runtime_info_AUTO_ROTATION_ENABLED_positive1(void);
 120 static void utc_runtime_info_AUTO_ROTATION_ENABLED_positive2(void);
 121 static void utc_runtime_info_AUTO_ROTATION_ENABLED_positive3(void);
 122 static void utc_runtime_info_SILENT_MODE_ENABLED_negative1(void);
 123 static void utc_runtime_info_SILENT_MODE_ENABLED_negative2(void);
 124 static void utc_runtime_info_SILENT_MODE_ENABLED_negative3(void);
 125 static void utc_runtime_info_SILENT_MODE_ENABLED_positive1(void);
 126 static void utc_runtime_info_SILENT_MODE_ENABLED_positive2(void);
 127 static void utc_runtime_info_SILENT_MODE_ENABLED_positive3(void);
 128 static void utc_runtime_info_USB_TETHERING_ENABLED_negative1(void);
 129 static void utc_runtime_info_USB_TETHERING_ENABLED_negative2(void);
 130 static void utc_runtime_info_USB_TETHERING_ENABLED_negative3(void);
 131 static void utc_runtime_info_USB_TETHERING_ENABLED_positive1(void);
 132 static void utc_runtime_info_USB_TETHERING_ENABLED_positive2(void);
 133 static void utc_runtime_info_USB_TETHERING_ENABLED_positive3(void);
 134 static void utc_runtime_info_VIBRATION_ENABLED_negative1(void);
 135 static void utc_runtime_info_VIBRATION_ENABLED_negative2(void);
 136 static void utc_runtime_info_VIBRATION_ENABLED_negative3(void);
 137 static void utc_runtime_info_VIBRATION_ENABLED_positive1(void);
 138 static void utc_runtime_info_VIBRATION_ENABLED_positive2(void);
 139 static void utc_runtime_info_VIBRATION_ENABLED_positive3(void);
 140 static void utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative1(void);
 141 static void utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative2(void);
 142 static void utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative3(void);
 143 static void utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive1(void);
 144 static void utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive2(void);
 145 static void utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive3(void);
 146 static void utc_runtime_info_WIFI_STATUS_negative1(void);
 147 static void utc_runtime_info_WIFI_STATUS_negative2(void);
 148 static void utc_runtime_info_WIFI_STATUS_negative3(void);
 149 static void utc_runtime_info_WIFI_STATUS_positive1(void);
 150 static void utc_runtime_info_WIFI_STATUS_positive2(void);
 151 static void utc_runtime_info_WIFI_STATUS_positive3(void);
 152 static void utc_runtime_info_TV_OUT_CONNECTED_negative1(void);
 153 static void utc_runtime_info_TV_OUT_CONNECTED_negative2(void);
 154 static void utc_runtime_info_TV_OUT_CONNECTED_negative3(void);
 155 static void utc_runtime_info_TV_OUT_CONNECTED_positive1(void);
 156 static void utc_runtime_info_TV_OUT_CONNECTED_positive2(void);
 157 static void utc_runtime_info_TV_OUT_CONNECTED_positive3(void);
 158 static void utc_runtime_info_AUDIO_JACK_STATUS_negative1(void);
 159 static void utc_runtime_info_AUDIO_JACK_STATUS_negative2(void);
 160 static void utc_runtime_info_AUDIO_JACK_STATUS_negative3(void);
 161 static void utc_runtime_info_AUDIO_JACK_STATUS_positive1(void);
 162 static void utc_runtime_info_AUDIO_JACK_STATUS_positive2(void);
 163 static void utc_runtime_info_AUDIO_JACK_STATUS_positive3(void);
 164 static void utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative1(void);
 165 static void utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative2(void);
 166 static void utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative3(void);
 167 static void utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive1(void);
 168 static void utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive2(void);
 169 static void utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive3(void);
 170 static void utc_runtime_info_USB_CONNECTED_negative1(void);
 171 static void utc_runtime_info_USB_CONNECTED_negative2(void);
 172 static void utc_runtime_info_USB_CONNECTED_negative3(void);
 173 static void utc_runtime_info_USB_CONNECTED_positive1(void);
 174 static void utc_runtime_info_USB_CONNECTED_positive2(void);
 175 static void utc_runtime_info_USB_CONNECTED_positive3(void);
 176 static void utc_runtime_info_CHARGER_CONNECTED_negative1(void);
 177 static void utc_runtime_info_CHARGER_CONNECTED_negative2(void);
 178 static void utc_runtime_info_CHARGER_CONNECTED_negative3(void);
 179 static void utc_runtime_info_CHARGER_CONNECTED_positive1(void);
 180 static void utc_runtime_info_CHARGER_CONNECTED_positive2(void);
 181 static void utc_runtime_info_CHARGER_CONNECTED_positive3(void);
 182 static void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative1(void);
 183 static void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative2(void);
 184 static void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative3(void);
 185 static void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive1(void);
 186 static void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive2(void);
 187 static void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive3(void);
 188 static void utc_runtime_info_set_changed_cb(void);
 189 static void utc_runtime_info_unset_changed_cb(void);
 190
 191 struct tet_testlist tet_testlist[] = {
 192         {utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative1, 1},
 193         {utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative2, 1},
 194         {utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative3, 1},
 195         {utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive1, 1},
 196         {utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive2, 1},
 197         {utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive3, 1},
 198         {utc_runtime_info_AUDIO_JACK_CONNECTED_negative1, 1},
 199         {utc_runtime_info_AUDIO_JACK_CONNECTED_negative2, 1},
 200         {utc_runtime_info_AUDIO_JACK_CONNECTED_negative3, 1},
 201         {utc_runtime_info_AUDIO_JACK_CONNECTED_positive1, 1},
 202         {utc_runtime_info_AUDIO_JACK_CONNECTED_positive2, 1},
 203         {utc_runtime_info_AUDIO_JACK_CONNECTED_positive3, 1},
 204         {utc_runtime_info_BATTERY_IS_CHARGING_negative1, 1},
 205         {utc_runtime_info_BATTERY_IS_CHARGING_negative2, 1},
 206         {utc_runtime_info_BATTERY_IS_CHARGING_negative3, 1},
 207         {utc_runtime_info_BATTERY_IS_CHARGING_positive1, 1},
 208         {utc_runtime_info_BATTERY_IS_CHARGING_positive2, 1},
 209         {utc_runtime_info_BATTERY_IS_CHARGING_positive3, 1},
 210         {utc_runtime_info_BLUETOOTH_ENABLED_negative1, 1},
 211         {utc_runtime_info_BLUETOOTH_ENABLED_negative2, 1},
 212         {utc_runtime_info_BLUETOOTH_ENABLED_negative3, 1},
 213         {utc_runtime_info_BLUETOOTH_ENABLED_positive1, 1},
 214         {utc_runtime_info_BLUETOOTH_ENABLED_positive2, 1},
 215         {utc_runtime_info_BLUETOOTH_ENABLED_positive3, 1},
 216         {utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative1, 1},
 217         {utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative2, 1},
 218         {utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative3, 1},
 219         {utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive1, 1},
 220         {utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive2, 1},
 221         {utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive3, 1},
 222         {utc_runtime_info_DATA_ROAMING_ENABLED_negative1, 1},
 223         {utc_runtime_info_DATA_ROAMING_ENABLED_negative2, 1},
 224         {utc_runtime_info_DATA_ROAMING_ENABLED_negative3, 1},
 225         {utc_runtime_info_DATA_ROAMING_ENABLED_positive1, 1},
 226         {utc_runtime_info_DATA_ROAMING_ENABLED_positive2, 1},
 227         {utc_runtime_info_DATA_ROAMING_ENABLED_positive3, 1},
 228         {utc_runtime_info_FIRST_DAY_OF_WEEK_negative1, 1},
 229         {utc_runtime_info_FIRST_DAY_OF_WEEK_negative2, 1},
 230         {utc_runtime_info_FIRST_DAY_OF_WEEK_negative3, 1},
 231         {utc_runtime_info_FIRST_DAY_OF_WEEK_positive1, 1},
 232         {utc_runtime_info_FIRST_DAY_OF_WEEK_positive2, 1},
 233         {utc_runtime_info_FIRST_DAY_OF_WEEK_positive3, 1},
 234         {utc_runtime_info_FLIGHT_MODE_ENABLED_negative1, 1},
 235         {utc_runtime_info_FLIGHT_MODE_ENABLED_negative2, 1},
 236         {utc_runtime_info_FLIGHT_MODE_ENABLED_negative3, 1},
 237         {utc_runtime_info_FLIGHT_MODE_ENABLED_positive1, 1},
 238         {utc_runtime_info_FLIGHT_MODE_ENABLED_positive2, 1},
 239         {utc_runtime_info_FLIGHT_MODE_ENABLED_positive3, 1},
 240         {utc_runtime_info_GPS_STATUS_negative1, 1},
 241         {utc_runtime_info_GPS_STATUS_negative2, 1},
 242         {utc_runtime_info_GPS_STATUS_negative3, 1},
 243         {utc_runtime_info_GPS_STATUS_positive1, 1},
 244         {utc_runtime_info_GPS_STATUS_positive2, 1},
 245         {utc_runtime_info_GPS_STATUS_positive3, 1},
 246         {utc_runtime_info_LANGUAGE_negative1, 1},
 247         {utc_runtime_info_LANGUAGE_negative2, 1},
 248         {utc_runtime_info_LANGUAGE_negative3, 1},
 249         {utc_runtime_info_LANGUAGE_positive1, 1},
 250         {utc_runtime_info_LANGUAGE_positive2, 1},
 251         {utc_runtime_info_LANGUAGE_positive3, 1},
 252         {utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative1, 1},
 253         {utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative2, 1},
 254         {utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative3, 1},
 255         {utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive1, 1},
 256         {utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive2, 1},
 257         {utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive3, 1},
 258         {utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative1, 1},
 259         {utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative2, 1},
 260         {utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative3, 1},
 261         {utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive1, 1},
 262         {utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive2, 1},
 263         {utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive3, 1},
 264         {utc_runtime_info_LOCATION_SERVICE_ENABLED_negative1, 1},
 265         {utc_runtime_info_LOCATION_SERVICE_ENABLED_negative2, 1},
 266         {utc_runtime_info_LOCATION_SERVICE_ENABLED_negative3, 1},
 267         {utc_runtime_info_LOCATION_SERVICE_ENABLED_positive1, 1},
 268         {utc_runtime_info_LOCATION_SERVICE_ENABLED_positive2, 1},
 269         {utc_runtime_info_LOCATION_SERVICE_ENABLED_positive3, 1},
 270         {utc_runtime_info_PACKET_DATA_ENABLED_negative1, 1},
 271         {utc_runtime_info_PACKET_DATA_ENABLED_negative2, 1},
 272         {utc_runtime_info_PACKET_DATA_ENABLED_negative3, 1},
 273         {utc_runtime_info_PACKET_DATA_ENABLED_positive1, 1},
 274         {utc_runtime_info_PACKET_DATA_ENABLED_positive2, 1},
 275         {utc_runtime_info_PACKET_DATA_ENABLED_positive3, 1},
 276         {utc_runtime_info_REGION_negative1, 1},
 277         {utc_runtime_info_REGION_negative2, 1},
 278         {utc_runtime_info_REGION_negative3, 1},
 279         {utc_runtime_info_REGION_positive1, 1},
 280         {utc_runtime_info_REGION_positive2, 1},
 281         {utc_runtime_info_REGION_positive3, 1},
 282         {utc_runtime_info_AUTO_ROTATION_ENABLED_negative1, 1},
 283         {utc_runtime_info_AUTO_ROTATION_ENABLED_negative2, 1},
 284         {utc_runtime_info_AUTO_ROTATION_ENABLED_negative3, 1},
 285         {utc_runtime_info_AUTO_ROTATION_ENABLED_positive1, 1},
 286         {utc_runtime_info_AUTO_ROTATION_ENABLED_positive2, 1},
 287         {utc_runtime_info_AUTO_ROTATION_ENABLED_positive3, 1},
 288         {utc_runtime_info_SILENT_MODE_ENABLED_negative1, 1},
 289         {utc_runtime_info_SILENT_MODE_ENABLED_negative2, 1},
 290         {utc_runtime_info_SILENT_MODE_ENABLED_negative3, 1},
 291         {utc_runtime_info_SILENT_MODE_ENABLED_positive1, 1},
 292         {utc_runtime_info_SILENT_MODE_ENABLED_positive2, 1},
 293         {utc_runtime_info_SILENT_MODE_ENABLED_positive3, 1},
 294         {utc_runtime_info_USB_TETHERING_ENABLED_negative1, 1},
 295         {utc_runtime_info_USB_TETHERING_ENABLED_negative2, 1},
 296         {utc_runtime_info_USB_TETHERING_ENABLED_negative3, 1},
 297         {utc_runtime_info_USB_TETHERING_ENABLED_positive1, 1},
 298         {utc_runtime_info_USB_TETHERING_ENABLED_positive2, 1},
 299         {utc_runtime_info_USB_TETHERING_ENABLED_positive3, 1},
 300         {utc_runtime_info_VIBRATION_ENABLED_negative1, 1},
 301         {utc_runtime_info_VIBRATION_ENABLED_negative2, 1},
 302         {utc_runtime_info_VIBRATION_ENABLED_negative3, 1},
 303         {utc_runtime_info_VIBRATION_ENABLED_positive1, 1},
 304         {utc_runtime_info_VIBRATION_ENABLED_positive2, 1},
 305         {utc_runtime_info_VIBRATION_ENABLED_positive3, 1},
 306         {utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative1, 1},
 307         {utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative2, 1},
 308         {utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative3, 1},
 309         {utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive1, 1},
 310         {utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive2, 1},
 311         {utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive3, 1},
 312         {utc_runtime_info_WIFI_STATUS_negative1, 1},
 313         {utc_runtime_info_WIFI_STATUS_negative2, 1},
 314         {utc_runtime_info_WIFI_STATUS_negative3, 1},
 315         {utc_runtime_info_WIFI_STATUS_positive1, 1},
 316         {utc_runtime_info_WIFI_STATUS_positive2, 1},
 317         {utc_runtime_info_WIFI_STATUS_positive3, 1},
 318         {utc_runtime_info_TV_OUT_CONNECTED_negative1, 1},
 319         {utc_runtime_info_TV_OUT_CONNECTED_negative2, 1},
 320         {utc_runtime_info_TV_OUT_CONNECTED_negative3, 1},
 321         {utc_runtime_info_TV_OUT_CONNECTED_positive1, 1},
 322         {utc_runtime_info_TV_OUT_CONNECTED_positive2, 1},
 323         {utc_runtime_info_TV_OUT_CONNECTED_positive3, 1},
 324         {utc_runtime_info_AUDIO_JACK_STATUS_negative1, 1},
 325         {utc_runtime_info_AUDIO_JACK_STATUS_negative2, 1},
 326         {utc_runtime_info_AUDIO_JACK_STATUS_negative3, 1},
 327         {utc_runtime_info_AUDIO_JACK_STATUS_positive1, 1},
 328         {utc_runtime_info_AUDIO_JACK_STATUS_positive2, 1},
 329         {utc_runtime_info_AUDIO_JACK_STATUS_positive3, 1},
 330         {utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative1, 1},
 331         {utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative2, 1},
 332         {utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative3, 1},
 333         {utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive1, 1},
 334         {utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive2, 1},
 335         {utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive3, 1},
 336         {utc_runtime_info_USB_CONNECTED_negative1, 1},
 337         {utc_runtime_info_USB_CONNECTED_negative2, 1},
 338         {utc_runtime_info_USB_CONNECTED_negative3, 1},
 339         {utc_runtime_info_USB_CONNECTED_positive1, 1},
 340         {utc_runtime_info_USB_CONNECTED_positive2, 1},
 341         {utc_runtime_info_USB_CONNECTED_positive3, 1},
 342         {utc_runtime_info_CHARGER_CONNECTED_negative1, 1},
 343         {utc_runtime_info_CHARGER_CONNECTED_negative2, 1},
 344         {utc_runtime_info_CHARGER_CONNECTED_negative3, 1},
 345         {utc_runtime_info_CHARGER_CONNECTED_positive1, 1},
 346         {utc_runtime_info_CHARGER_CONNECTED_positive2, 1},
 347         {utc_runtime_info_CHARGER_CONNECTED_positive3, 1},
 348         {utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative1, 1},
 349         {utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative2, 1},
 350         {utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative3, 1},
 351         {utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive1, 1},
 352         {utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive2, 1},
 353         {utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive3, 1},
 354         {utc_runtime_info_set_changed_cb, 1},
 355         {utc_runtime_info_unset_changed_cb, 1},
 356         {NULL, 0},
 357 };
 358
 359 static void startup(void)
 360 {
 361
 362 }
 363
 364 static void cleanup(void)
 365 {
 366         /* end of TC */
 367 }
 368
 369 void runtime_info_changed(runtime_info_key_e key, void *user_data)
 370 {
 371
 372 }
 373
 374 /* negative1 : invalid data-type */
 375 /* negative2 : invalid input-param */
 376 /* negative3 : invalid changed callback */
 377 /* positive1 : get the value */
 378 /* positive2 : set changed callback */
 379 /* positive3 : unset changed callback */
 380
 381 void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative1(void)
 382 {
 383         char *TC_NAME = __FUNCTION__;
 384         int retcode;
 385         runtime_info_key_e key = RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED;
 386         char *value;
 387
 388         retcode = runtime_info_get_value_string(key, &value);
 389
 390         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 391                 dts_pass(TC_NAME, "passed");
 392         else
 393                 dts_fail(TC_NAME, "failed");
 394 }
 395
 396 void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative2(void)
 397 {
 398         char *TC_NAME = __FUNCTION__;
 399         int retcode;
 400         runtime_info_key_e key = RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED;
 401
 402         retcode = runtime_info_get_value_bool(key, NULL);
 403
 404         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 405                 dts_pass(TC_NAME, "passed");
 406         else
 407                 dts_fail(TC_NAME, "failed");
 408 }
 409
 410 void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_negative3(void)
 411 {
 412         char *TC_NAME = __FUNCTION__;
 413         int retcode;
 414         runtime_info_key_e key = RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED;
 415
 416         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
 417
 418         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 419                 dts_pass(TC_NAME, "passed");
 420         else
 421                 dts_fail(TC_NAME, "failed");
 422 }
 423
 424 void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive1(void)
 425 {
 426         char *TC_NAME = __FUNCTION__;
 427         int retcode;
 428         runtime_info_key_e key = RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED;
 429         bool value;
 430
 431         retcode = runtime_info_get_value_bool(key, &value);
 432
 433         if (retcode == RUNTIME_INFO_ERROR_NONE)
 434                 dts_pass(TC_NAME, "passed");
 435         else
 436                 dts_fail(TC_NAME, "failed");
 437 }
 438
 439 void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive2(void)
 440 {
 441         char *TC_NAME = __FUNCTION__;
 442         int retcode;
 443         runtime_info_key_e key = RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED;
 444
 445         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 446
 447         if (retcode == RUNTIME_INFO_ERROR_NONE)
 448                 dts_pass(TC_NAME, "passed");
 449         else
 450                 dts_fail(TC_NAME, "failed");
 451 }
 452
 453 void utc_runtime_info_24HOUR_CLOCK_FORMAT_ENABLED_positive3(void)
 454 {
 455         char *TC_NAME = __FUNCTION__;
 456         int retcode;
 457         runtime_info_key_e key = RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED;
 458
 459         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 460
 461         retcode = runtime_info_unset_changed_cb(key);
 462
 463         if (retcode == RUNTIME_INFO_ERROR_NONE)
 464                 dts_pass(TC_NAME, "passed");
 465         else
 466                 dts_fail(TC_NAME, "failed");
 467 }
 468
 469 void utc_runtime_info_AUDIO_JACK_CONNECTED_negative1(void)
 470 {
 471         char *TC_NAME = __FUNCTION__;
 472         int retcode;
 473         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED;
 474         char *value;
 475
 476         retcode = runtime_info_get_value_string(key, &value);
 477
 478         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 479                 dts_pass(TC_NAME, "passed");
 480         else
 481                 dts_fail(TC_NAME, "failed");
 482 }
 483
 484 void utc_runtime_info_AUDIO_JACK_CONNECTED_negative2(void)
 485 {
 486         char *TC_NAME = __FUNCTION__;
 487         int retcode;
 488         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED;
 489
 490         retcode = runtime_info_get_value_bool(key, NULL);
 491
 492         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 493                 dts_pass(TC_NAME, "passed");
 494         else
 495                 dts_fail(TC_NAME, "failed");
 496 }
 497
 498 void utc_runtime_info_AUDIO_JACK_CONNECTED_negative3(void)
 499 {
 500         char *TC_NAME = __FUNCTION__;
 501         int retcode;
 502         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED;
 503
 504         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
 505
 506         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 507                 dts_pass(TC_NAME, "passed");
 508         else
 509                 dts_fail(TC_NAME, "failed");
 510 }
 511
 512 void utc_runtime_info_AUDIO_JACK_CONNECTED_positive1(void)
 513 {
 514         char *TC_NAME = __FUNCTION__;
 515         int retcode;
 516         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED;
 517         bool value;
 518
 519         retcode = runtime_info_get_value_bool(key, &value);
 520
 521         if (retcode == RUNTIME_INFO_ERROR_NONE)
 522                 dts_pass(TC_NAME, "passed");
 523         else
 524                 dts_fail(TC_NAME, "failed");
 525 }
 526
 527 void utc_runtime_info_AUDIO_JACK_CONNECTED_positive2(void)
 528 {
 529         char *TC_NAME = __FUNCTION__;
 530         int retcode;
 531         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED;
 532
 533         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 534
 535         if (retcode == RUNTIME_INFO_ERROR_NONE)
 536                 dts_pass(TC_NAME, "passed");
 537         else
 538                 dts_fail(TC_NAME, "failed");
 539 }
 540
 541 void utc_runtime_info_AUDIO_JACK_CONNECTED_positive3(void)
 542 {
 543         char *TC_NAME = __FUNCTION__;
 544         int retcode;
 545         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED;
 546
 547         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 548
 549         retcode = runtime_info_unset_changed_cb(key);
 550
 551         if (retcode == RUNTIME_INFO_ERROR_NONE)
 552                 dts_pass(TC_NAME, "passed");
 553         else
 554                 dts_fail(TC_NAME, "failed");
 555 }
 556
 557 void utc_runtime_info_BATTERY_IS_CHARGING_negative1(void)
 558 {
 559         char *TC_NAME = __FUNCTION__;
 560         int retcode;
 561         runtime_info_key_e key = RUNTIME_INFO_KEY_BATTERY_IS_CHARGING;
 562         char *value;
 563
 564         retcode = runtime_info_get_value_string(key, &value);
 565
 566         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 567                 dts_pass(TC_NAME, "passed");
 568         else
 569                 dts_fail(TC_NAME, "failed");
 570 }
 571
 572 void utc_runtime_info_BATTERY_IS_CHARGING_negative2(void)
 573 {
 574         char *TC_NAME = __FUNCTION__;
 575         int retcode;
 576         runtime_info_key_e key = RUNTIME_INFO_KEY_BATTERY_IS_CHARGING;
 577
 578         retcode = runtime_info_get_value_bool(key, NULL);
 579
 580         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 581                 dts_pass(TC_NAME, "passed");
 582         else
 583                 dts_fail(TC_NAME, "failed");
 584 }
 585
 586 void utc_runtime_info_BATTERY_IS_CHARGING_negative3(void)
 587 {
 588         char *TC_NAME = __FUNCTION__;
 589         int retcode;
 590         runtime_info_key_e key = RUNTIME_INFO_KEY_BATTERY_IS_CHARGING;
 591
 592         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
 593
 594         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 595                 dts_pass(TC_NAME, "passed");
 596         else
 597                 dts_fail(TC_NAME, "failed");
 598 }
 599
 600 void utc_runtime_info_BATTERY_IS_CHARGING_positive1(void)
 601 {
 602         char *TC_NAME = __FUNCTION__;
 603         int retcode;
 604         runtime_info_key_e key = RUNTIME_INFO_KEY_BATTERY_IS_CHARGING;
 605         bool value;
 606
 607         retcode = runtime_info_get_value_bool(key, &value);
 608
 609         if (retcode == RUNTIME_INFO_ERROR_NONE)
 610                 dts_pass(TC_NAME, "passed");
 611         else
 612                 dts_fail(TC_NAME, "failed");
 613 }
 614
 615 void utc_runtime_info_BATTERY_IS_CHARGING_positive2(void)
 616 {
 617         char *TC_NAME = __FUNCTION__;
 618         int retcode;
 619         runtime_info_key_e key = RUNTIME_INFO_KEY_BATTERY_IS_CHARGING;
 620
 621         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 622
 623         if (retcode == RUNTIME_INFO_ERROR_NONE)
 624                 dts_pass(TC_NAME, "passed");
 625         else
 626                 dts_fail(TC_NAME, "failed");
 627 }
 628
 629 void utc_runtime_info_BATTERY_IS_CHARGING_positive3(void)
 630 {
 631         char *TC_NAME = __FUNCTION__;
 632         int retcode;
 633         runtime_info_key_e key = RUNTIME_INFO_KEY_BATTERY_IS_CHARGING;
 634
 635         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 636
 637         retcode = runtime_info_unset_changed_cb(key);
 638
 639         if (retcode == RUNTIME_INFO_ERROR_NONE)
 640                 dts_pass(TC_NAME, "passed");
 641         else
 642                 dts_fail(TC_NAME, "failed");
 643 }
 644
 645 void utc_runtime_info_BLUETOOTH_ENABLED_negative1(void)
 646 {
 647         char *TC_NAME = __FUNCTION__;
 648         int retcode;
 649         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_ENABLED;
 650         char *value;
 651
 652         retcode = runtime_info_get_value_string(key, &value);
 653
 654         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 655                 dts_pass(TC_NAME, "passed");
 656         else
 657                 dts_fail(TC_NAME, "failed");
 658 }
 659
 660 void utc_runtime_info_BLUETOOTH_ENABLED_negative2(void)
 661 {
 662         char *TC_NAME = __FUNCTION__;
 663         int retcode;
 664         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_ENABLED;
 665
 666         retcode = runtime_info_get_value_bool(key, NULL);
 667
 668         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 669                 dts_pass(TC_NAME, "passed");
 670         else
 671                 dts_fail(TC_NAME, "failed");
 672 }
 673
 674 void utc_runtime_info_BLUETOOTH_ENABLED_negative3(void)
 675 {
 676         char *TC_NAME = __FUNCTION__;
 677         int retcode;
 678         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_ENABLED;
 679
 680         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
 681
 682         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 683                 dts_pass(TC_NAME, "passed");
 684         else
 685                 dts_fail(TC_NAME, "failed");
 686 }
 687
 688 void utc_runtime_info_BLUETOOTH_ENABLED_positive1(void)
 689 {
 690         char *TC_NAME = __FUNCTION__;
 691         int retcode;
 692         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_ENABLED;
 693         bool value;
 694
 695         retcode = runtime_info_get_value_bool(key, &value);
 696
 697         if (retcode == RUNTIME_INFO_ERROR_NONE)
 698                 dts_pass(TC_NAME, "passed");
 699         else
 700                 dts_fail(TC_NAME, "failed");
 701 }
 702
 703 void utc_runtime_info_BLUETOOTH_ENABLED_positive2(void)
 704 {
 705         char *TC_NAME = __FUNCTION__;
 706         int retcode;
 707         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_ENABLED;
 708
 709         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 710
 711         if (retcode == RUNTIME_INFO_ERROR_NONE)
 712                 dts_pass(TC_NAME, "passed");
 713         else
 714                 dts_fail(TC_NAME, "failed");
 715 }
 716
 717 void utc_runtime_info_BLUETOOTH_ENABLED_positive3(void)
 718 {
 719         char *TC_NAME = __FUNCTION__;
 720         int retcode;
 721         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_ENABLED;
 722
 723         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 724
 725         retcode = runtime_info_unset_changed_cb(key);
 726
 727         if (retcode == RUNTIME_INFO_ERROR_NONE)
 728                 dts_pass(TC_NAME, "passed");
 729         else
 730                 dts_fail(TC_NAME, "failed");
 731 }
 732
 733 void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative1(void)
 734 {
 735         char *TC_NAME = __FUNCTION__;
 736         int retcode;
 737         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_TETHERING_ENABLED;
 738         char *value;
 739
 740         retcode = runtime_info_get_value_string(key, &value);
 741
 742         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 743                 dts_pass(TC_NAME, "passed");
 744         else
 745                 dts_fail(TC_NAME, "failed");
 746 }
 747
 748 void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative2(void)
 749 {
 750         char *TC_NAME = __FUNCTION__;
 751         int retcode;
 752         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_TETHERING_ENABLED;
 753
 754         retcode = runtime_info_get_value_bool(key, NULL);
 755
 756         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 757                 dts_pass(TC_NAME, "passed");
 758         else
 759                 dts_fail(TC_NAME, "failed");
 760 }
 761
 762 void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_negative3(void)
 763 {
 764         char *TC_NAME = __FUNCTION__;
 765         int retcode;
 766         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_TETHERING_ENABLED;
 767
 768         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
 769
 770         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 771                 dts_pass(TC_NAME, "passed");
 772         else
 773                 dts_fail(TC_NAME, "failed");
 774 }
 775
 776 void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive1(void)
 777 {
 778         char *TC_NAME = __FUNCTION__;
 779         int retcode;
 780         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_TETHERING_ENABLED;
 781         bool value;
 782
 783         retcode = runtime_info_get_value_bool(key, &value);
 784
 785         if (retcode == RUNTIME_INFO_ERROR_NONE)
 786                 dts_pass(TC_NAME, "passed");
 787         else
 788                 dts_fail(TC_NAME, "failed");
 789 }
 790
 791 void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive2(void)
 792 {
 793         char *TC_NAME = __FUNCTION__;
 794         int retcode;
 795         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_TETHERING_ENABLED;
 796
 797         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 798
 799         if (retcode == RUNTIME_INFO_ERROR_NONE)
 800                 dts_pass(TC_NAME, "passed");
 801         else
 802                 dts_fail(TC_NAME, "failed");
 803 }
 804
 805 void utc_runtime_info_BLUETOOTH_TETHERING_ENABLED_positive3(void)
 806 {
 807         char *TC_NAME = __FUNCTION__;
 808         int retcode;
 809         runtime_info_key_e key = RUNTIME_INFO_KEY_BLUETOOTH_TETHERING_ENABLED;
 810
 811         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 812
 813         retcode = runtime_info_unset_changed_cb(key);
 814
 815         if (retcode == RUNTIME_INFO_ERROR_NONE)
 816                 dts_pass(TC_NAME, "passed");
 817         else
 818                 dts_fail(TC_NAME, "failed");
 819 }
 820
 821 void utc_runtime_info_DATA_ROAMING_ENABLED_negative1(void){
 822         char *TC_NAME = __FUNCTION__;
 823         int retcode;
 824         runtime_info_key_e key = RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED;
 825         char *value;
 826
 827         retcode = runtime_info_get_value_string(key, &value);
 828
 829         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 830                 dts_pass(TC_NAME, "passed");
 831         else
 832                 dts_fail(TC_NAME, "failed");
 833 }
 834
 835 void utc_runtime_info_DATA_ROAMING_ENABLED_negative2(void)
 836 {
 837         char *TC_NAME = __FUNCTION__;
 838         int retcode;
 839         runtime_info_key_e key = RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED;
 840
 841         retcode = runtime_info_get_value_bool(key, NULL);
 842
 843         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 844                 dts_pass(TC_NAME, "passed");
 845         else
 846                 dts_fail(TC_NAME, "failed");
 847 }
 848
 849 void utc_runtime_info_DATA_ROAMING_ENABLED_negative3(void)
 850 {
 851         char *TC_NAME = __FUNCTION__;
 852         int retcode;
 853         runtime_info_key_e key = RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED;
 854
 855         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
 856
 857         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 858                 dts_pass(TC_NAME, "passed");
 859         else
 860                 dts_fail(TC_NAME, "failed");
 861 }
 862
 863 void utc_runtime_info_DATA_ROAMING_ENABLED_positive1(void)
 864 {
 865         char *TC_NAME = __FUNCTION__;
 866         int retcode;
 867         runtime_info_key_e key = RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED;
 868         bool value;
 869
 870         retcode = runtime_info_get_value_bool(key, &value);
 871
 872         if (retcode == RUNTIME_INFO_ERROR_NONE)
 873                 dts_pass(TC_NAME, "passed");
 874         else
 875                 dts_fail(TC_NAME, "failed");
 876 }
 877
 878 void utc_runtime_info_DATA_ROAMING_ENABLED_positive2(void)
 879 {
 880         char *TC_NAME = __FUNCTION__;
 881         int retcode;
 882         runtime_info_key_e key = RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED;
 883
 884         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 885
 886         if (retcode == RUNTIME_INFO_ERROR_NONE)
 887                 dts_pass(TC_NAME, "passed");
 888         else
 889                 dts_fail(TC_NAME, "failed");
 890 }
 891
 892 void utc_runtime_info_DATA_ROAMING_ENABLED_positive3(void)
 893 {
 894         char *TC_NAME = __FUNCTION__;
 895         int retcode;
 896         runtime_info_key_e key = RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED;
 897
 898         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 899
 900         retcode = runtime_info_unset_changed_cb(key);
 901
 902         if (retcode == RUNTIME_INFO_ERROR_NONE)
 903                 dts_pass(TC_NAME, "passed");
 904         else
 905                 dts_fail(TC_NAME, "failed");
 906 }
 907
 908 void utc_runtime_info_FIRST_DAY_OF_WEEK_negative1(void)
 909 {
 910         char *TC_NAME = __FUNCTION__;
 911         int retcode;
 912         runtime_info_key_e key = RUNTIME_INFO_KEY_FIRST_DAY_OF_WEEK;
 913         char *value;
 914
 915         retcode = runtime_info_get_value_string(key, &value);
 916
 917         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 918                 dts_pass(TC_NAME, "passed");
 919         else
 920                 dts_fail(TC_NAME, "failed");
 921 }
 922
 923 void utc_runtime_info_FIRST_DAY_OF_WEEK_negative2(void)
 924 {
 925         char *TC_NAME = __FUNCTION__;
 926         int retcode;
 927         runtime_info_key_e key = RUNTIME_INFO_KEY_FIRST_DAY_OF_WEEK;
 928
 929         retcode = runtime_info_get_value_int(key, NULL);
 930
 931         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 932                 dts_pass(TC_NAME, "passed");
 933         else
 934                 dts_fail(TC_NAME, "failed");
 935 }
 936
 937 void utc_runtime_info_FIRST_DAY_OF_WEEK_negative3(void)
 938 {
 939         char *TC_NAME = __FUNCTION__;
 940         int retcode;
 941         runtime_info_key_e key = RUNTIME_INFO_KEY_FIRST_DAY_OF_WEEK;
 942
 943         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
 944
 945         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
 946                 dts_pass(TC_NAME, "passed");
 947         else
 948                 dts_fail(TC_NAME, "failed");
 949 }
 950
 951 void utc_runtime_info_FIRST_DAY_OF_WEEK_positive1(void)
 952 {
 953         char *TC_NAME = __FUNCTION__;
 954         int retcode;
 955         runtime_info_key_e key = RUNTIME_INFO_KEY_FIRST_DAY_OF_WEEK;
 956         int value;
 957
 958         retcode = runtime_info_get_value_int(key, &value);
 959
 960         if (retcode == RUNTIME_INFO_ERROR_NONE)
 961                 dts_pass(TC_NAME, "passed");
 962         else
 963                 dts_fail(TC_NAME, "failed");
 964 }
 965
 966 void utc_runtime_info_FIRST_DAY_OF_WEEK_positive2(void)
 967 {
 968         char *TC_NAME = __FUNCTION__;
 969         int retcode;
 970         runtime_info_key_e key = RUNTIME_INFO_KEY_FIRST_DAY_OF_WEEK;
 971
 972         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 973
 974         if (retcode == RUNTIME_INFO_ERROR_NONE)
 975                 dts_pass(TC_NAME, "passed");
 976         else
 977                 dts_fail(TC_NAME, "failed");
 978 }
 979
 980 void utc_runtime_info_FIRST_DAY_OF_WEEK_positive3(void)
 981 {
 982         char *TC_NAME = __FUNCTION__;
 983         int retcode;
 984         runtime_info_key_e key = RUNTIME_INFO_KEY_FIRST_DAY_OF_WEEK;
 985
 986         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
 987
 988         retcode = runtime_info_unset_changed_cb(key);
 989
 990         if (retcode == RUNTIME_INFO_ERROR_NONE)
 991                 dts_pass(TC_NAME, "passed");
 992         else
 993                 dts_fail(TC_NAME, "failed");
 994 }
 995
 996 void utc_runtime_info_FLIGHT_MODE_ENABLED_negative1(void)
 997 {
 998         char *TC_NAME = __FUNCTION__;
 999         int retcode;
1000         runtime_info_key_e key = RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED;
1001         char *value;
1002
1003         retcode = runtime_info_get_value_string(key, &value);
1004
1005         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1006                 dts_pass(TC_NAME, "passed");
1007         else
1008                 dts_fail(TC_NAME, "failed");
1009 }
1010
1011 void utc_runtime_info_FLIGHT_MODE_ENABLED_negative2(void)
1012 {
1013         char *TC_NAME = __FUNCTION__;
1014         int retcode;
1015         runtime_info_key_e key = RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED;
1016
1017         retcode = runtime_info_get_value_bool(key, NULL);
1018
1019         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1020                 dts_pass(TC_NAME, "passed");
1021         else
1022                 dts_fail(TC_NAME, "failed");
1023 }
1024
1025 void utc_runtime_info_FLIGHT_MODE_ENABLED_negative3(void)
1026 {
1027         char *TC_NAME = __FUNCTION__;
1028         int retcode;
1029         runtime_info_key_e key = RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED;
1030
1031         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1032
1033         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1034                 dts_pass(TC_NAME, "passed");
1035         else
1036                 dts_fail(TC_NAME, "failed");
1037 }
1038
1039 void utc_runtime_info_FLIGHT_MODE_ENABLED_positive1(void)
1040 {
1041         char *TC_NAME = __FUNCTION__;
1042         int retcode;
1043         runtime_info_key_e key = RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED;
1044         bool value;
1045
1046         retcode = runtime_info_get_value_bool(key, &value);
1047
1048         if (retcode == RUNTIME_INFO_ERROR_NONE)
1049                 dts_pass(TC_NAME, "passed");
1050         else
1051                 dts_fail(TC_NAME, "failed");
1052 }
1053
1054 void utc_runtime_info_FLIGHT_MODE_ENABLED_positive2(void)
1055 {
1056         char *TC_NAME = __FUNCTION__;
1057         int retcode;
1058         runtime_info_key_e key = RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED;
1059
1060         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1061
1062         if (retcode == RUNTIME_INFO_ERROR_NONE)
1063                 dts_pass(TC_NAME, "passed");
1064         else
1065                 dts_fail(TC_NAME, "failed");
1066 }
1067
1068 void utc_runtime_info_FLIGHT_MODE_ENABLED_positive3(void)
1069 {
1070         char *TC_NAME = __FUNCTION__;
1071         int retcode;
1072         runtime_info_key_e key = RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED;
1073
1074         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1075
1076         retcode = runtime_info_unset_changed_cb(key);
1077
1078         if (retcode == RUNTIME_INFO_ERROR_NONE)
1079                 dts_pass(TC_NAME, "passed");
1080         else
1081                 dts_fail(TC_NAME, "failed");
1082 }
1083
1084 void utc_runtime_info_GPS_STATUS_negative1(void)
1085 {
1086         char *TC_NAME = __FUNCTION__;
1087         int retcode;
1088         runtime_info_key_e key = RUNTIME_INFO_KEY_GPS_STATUS;
1089         char *value;
1090
1091         retcode = runtime_info_get_value_string(key, &value);
1092
1093         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1094                 dts_pass(TC_NAME, "passed");
1095         else
1096                 dts_fail(TC_NAME, "failed");
1097 }
1098
1099 void utc_runtime_info_GPS_STATUS_negative2(void)
1100 {
1101         char *TC_NAME = __FUNCTION__;
1102         int retcode;
1103         runtime_info_key_e key = RUNTIME_INFO_KEY_GPS_STATUS;
1104
1105         retcode = runtime_info_get_value_int(key, NULL);
1106
1107         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1108                 dts_pass(TC_NAME, "passed");
1109         else
1110                 dts_fail(TC_NAME, "failed");
1111 }
1112
1113 void utc_runtime_info_GPS_STATUS_negative3(void)
1114 {
1115         char *TC_NAME = __FUNCTION__;
1116         int retcode;
1117         runtime_info_key_e key = RUNTIME_INFO_KEY_GPS_STATUS;
1118
1119         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1120
1121         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1122                 dts_pass(TC_NAME, "passed");
1123         else
1124                 dts_fail(TC_NAME, "failed");
1125 }
1126
1127 void utc_runtime_info_GPS_STATUS_positive1(void)
1128 {
1129         char *TC_NAME = __FUNCTION__;
1130         int retcode;
1131         runtime_info_key_e key = RUNTIME_INFO_KEY_GPS_STATUS;
1132         int value;
1133
1134         retcode = runtime_info_get_value_int(key, &value);
1135
1136         if (retcode == RUNTIME_INFO_ERROR_NONE)
1137                 dts_pass(TC_NAME, "passed");
1138         else
1139                 dts_fail(TC_NAME, "failed");
1140 }
1141
1142 void utc_runtime_info_GPS_STATUS_positive2(void)
1143 {
1144         char *TC_NAME = __FUNCTION__;
1145         int retcode;
1146         runtime_info_key_e key = RUNTIME_INFO_KEY_GPS_STATUS;
1147
1148         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1149
1150         if (retcode == RUNTIME_INFO_ERROR_NONE)
1151                 dts_pass(TC_NAME, "passed");
1152         else
1153                 dts_fail(TC_NAME, "failed");
1154 }
1155
1156 void utc_runtime_info_GPS_STATUS_positive3(void)
1157 {
1158         char *TC_NAME = __FUNCTION__;
1159         int retcode;
1160         runtime_info_key_e key = RUNTIME_INFO_KEY_GPS_STATUS;
1161
1162         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1163
1164         retcode = runtime_info_unset_changed_cb(key);
1165
1166         if (retcode == RUNTIME_INFO_ERROR_NONE)
1167                 dts_pass(TC_NAME, "passed");
1168         else
1169                 dts_fail(TC_NAME, "failed");
1170 }
1171
1172 void utc_runtime_info_LANGUAGE_negative1(void)
1173 {
1174         char *TC_NAME = __FUNCTION__;
1175         int retcode;
1176         runtime_info_key_e key = RUNTIME_INFO_KEY_LANGUAGE;
1177         bool value;
1178
1179         retcode = runtime_info_get_value_bool(key, &value);
1180
1181         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1182                 dts_pass(TC_NAME, "passed");
1183         else
1184                 dts_fail(TC_NAME, "failed");
1185 }
1186
1187 void utc_runtime_info_LANGUAGE_negative2(void)
1188 {
1189         char *TC_NAME = __FUNCTION__;
1190         int retcode;
1191         runtime_info_key_e key = RUNTIME_INFO_KEY_LANGUAGE;
1192
1193         retcode = runtime_info_get_value_string(key, NULL);
1194
1195         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1196                 dts_pass(TC_NAME, "passed");
1197         else
1198                 dts_fail(TC_NAME, "failed");
1199 }
1200
1201 void utc_runtime_info_LANGUAGE_negative3(void)
1202 {
1203         char *TC_NAME = __FUNCTION__;
1204         int retcode;
1205         runtime_info_key_e key = RUNTIME_INFO_KEY_LANGUAGE;
1206
1207         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1208
1209         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1210                 dts_pass(TC_NAME, "passed");
1211         else
1212                 dts_fail(TC_NAME, "failed");
1213 }
1214
1215 void utc_runtime_info_LANGUAGE_positive1(void)
1216 {
1217         char *TC_NAME = __FUNCTION__;
1218         int retcode;
1219         runtime_info_key_e key = RUNTIME_INFO_KEY_LANGUAGE;
1220         char *value;
1221
1222         retcode = runtime_info_get_value_string(key, &value);
1223
1224         if (retcode == RUNTIME_INFO_ERROR_NONE)
1225                 dts_pass(TC_NAME, "passed");
1226         else
1227                 dts_fail(TC_NAME, "failed");
1228 }
1229
1230 void utc_runtime_info_LANGUAGE_positive2(void)
1231 {
1232         char *TC_NAME = __FUNCTION__;
1233         int retcode;
1234         runtime_info_key_e key = RUNTIME_INFO_KEY_LANGUAGE;
1235
1236         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1237
1238         if (retcode == RUNTIME_INFO_ERROR_NONE)
1239                 dts_pass(TC_NAME, "passed");
1240         else
1241                 dts_fail(TC_NAME, "failed");
1242 }
1243
1244 void utc_runtime_info_LANGUAGE_positive3(void)
1245 {
1246         char *TC_NAME = __FUNCTION__;
1247         int retcode;
1248         runtime_info_key_e key = RUNTIME_INFO_KEY_LANGUAGE;
1249
1250         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1251
1252         retcode = runtime_info_unset_changed_cb(key);
1253
1254         if (retcode == RUNTIME_INFO_ERROR_NONE)
1255                 dts_pass(TC_NAME, "passed");
1256         else
1257                 dts_fail(TC_NAME, "failed");
1258 }
1259
1260 void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative1(void)
1261 {
1262         char *TC_NAME = __FUNCTION__;
1263         int retcode;
1264         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_ADVANCED_GPS_ENABLED;
1265         char *value;
1266
1267         retcode = runtime_info_get_value_string(key, &value);
1268
1269         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1270                 dts_pass(TC_NAME, "passed");
1271         else
1272                 dts_fail(TC_NAME, "failed");
1273 }
1274
1275 void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative2(void)
1276 {
1277         char *TC_NAME = __FUNCTION__;
1278         int retcode;
1279         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_ADVANCED_GPS_ENABLED;
1280
1281         retcode = runtime_info_get_value_bool(key, NULL);
1282
1283         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1284                 dts_pass(TC_NAME, "passed");
1285         else
1286                 dts_fail(TC_NAME, "failed");
1287 }
1288
1289 void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_negative3(void)
1290 {
1291         char *TC_NAME = __FUNCTION__;
1292         int retcode;
1293         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_ADVANCED_GPS_ENABLED;
1294
1295         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1296
1297         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1298                 dts_pass(TC_NAME, "passed");
1299         else
1300                 dts_fail(TC_NAME, "failed");
1301 }
1302
1303 void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive1(void)
1304 {
1305         char *TC_NAME = __FUNCTION__;
1306         int retcode;
1307         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_ADVANCED_GPS_ENABLED;
1308         bool value;
1309
1310         retcode = runtime_info_get_value_bool(key, &value);
1311
1312         if (retcode == RUNTIME_INFO_ERROR_NONE)
1313                 dts_pass(TC_NAME, "passed");
1314         else
1315                 dts_fail(TC_NAME, "failed");
1316 }
1317
1318 void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive2(void)
1319 {
1320         char *TC_NAME = __FUNCTION__;
1321         int retcode;
1322         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_ADVANCED_GPS_ENABLED;
1323
1324         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1325
1326         if (retcode == RUNTIME_INFO_ERROR_NONE)
1327                 dts_pass(TC_NAME, "passed");
1328         else
1329                 dts_fail(TC_NAME, "failed");
1330 }
1331
1332 void utc_runtime_info_LOCATION_ADVANCED_GPS_ENABLED_positive3(void)
1333 {
1334         char *TC_NAME = __FUNCTION__;
1335         int retcode;
1336         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_ADVANCED_GPS_ENABLED;
1337
1338         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1339
1340         retcode = runtime_info_unset_changed_cb(key);
1341
1342         if (retcode == RUNTIME_INFO_ERROR_NONE)
1343                 dts_pass(TC_NAME, "passed");
1344         else
1345                 dts_fail(TC_NAME, "failed");
1346 }
1347
1348
1349 void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative1(void)
1350 {
1351         char *TC_NAME = __FUNCTION__;
1352         int retcode;
1353         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED;
1354         char *value;
1355
1356         retcode = runtime_info_get_value_string(key, &value);
1357
1358         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1359                 dts_pass(TC_NAME, "passed");
1360         else
1361                 dts_fail(TC_NAME, "failed");
1362 }
1363
1364 void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative2(void)
1365 {
1366         char *TC_NAME = __FUNCTION__;
1367         int retcode;
1368         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED;
1369
1370         retcode = runtime_info_get_value_bool(key, NULL);
1371
1372         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1373                 dts_pass(TC_NAME, "passed");
1374         else
1375                 dts_fail(TC_NAME, "failed");
1376 }
1377
1378 void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_negative3(void)
1379 {
1380         char *TC_NAME = __FUNCTION__;
1381         int retcode;
1382         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED;
1383
1384         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1385
1386         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1387                 dts_pass(TC_NAME, "passed");
1388         else
1389                 dts_fail(TC_NAME, "failed");
1390 }
1391
1392 void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive1(void)
1393 {
1394         char *TC_NAME = __FUNCTION__;
1395         int retcode;
1396         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED;
1397         bool value;
1398
1399         retcode = runtime_info_get_value_bool(key, &value);
1400
1401         if (retcode == RUNTIME_INFO_ERROR_NONE)
1402                 dts_pass(TC_NAME, "passed");
1403         else
1404                 dts_fail(TC_NAME, "failed");
1405 }
1406
1407 void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive2(void)
1408 {
1409         char *TC_NAME = __FUNCTION__;
1410         int retcode;
1411         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED;
1412
1413         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1414
1415         if (retcode == RUNTIME_INFO_ERROR_NONE)
1416                 dts_pass(TC_NAME, "passed");
1417         else
1418                 dts_fail(TC_NAME, "failed");
1419 }
1420
1421 void utc_runtime_info_LOCATION_NETWORK_POSITION_ENABLED_positive3(void)
1422 {
1423         char *TC_NAME = __FUNCTION__;
1424         int retcode;
1425         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED;
1426
1427         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1428
1429         retcode = runtime_info_unset_changed_cb(key);
1430
1431         if (retcode == RUNTIME_INFO_ERROR_NONE)
1432                 dts_pass(TC_NAME, "passed");
1433         else
1434                 dts_fail(TC_NAME, "failed");
1435 }
1436
1437 void utc_runtime_info_LOCATION_SERVICE_ENABLED_negative1(void)
1438 {
1439         char *TC_NAME = __FUNCTION__;
1440         int retcode;
1441         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED;
1442         char *value;
1443
1444         retcode = runtime_info_get_value_string(key, &value);
1445
1446         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1447                 dts_pass(TC_NAME, "passed");
1448         else
1449                 dts_fail(TC_NAME, "failed");
1450 }
1451
1452 void utc_runtime_info_LOCATION_SERVICE_ENABLED_negative2(void)
1453 {
1454         char *TC_NAME = __FUNCTION__;
1455         int retcode;
1456         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED;
1457
1458         retcode = runtime_info_get_value_bool(key, NULL);
1459
1460         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1461                 dts_pass(TC_NAME, "passed");
1462         else
1463                 dts_fail(TC_NAME, "failed");
1464 }
1465
1466 void utc_runtime_info_LOCATION_SERVICE_ENABLED_negative3(void)
1467 {
1468         char *TC_NAME = __FUNCTION__;
1469         int retcode;
1470         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED;
1471
1472         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1473
1474         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1475                 dts_pass(TC_NAME, "passed");
1476         else
1477                 dts_fail(TC_NAME, "failed");
1478 }
1479
1480 void utc_runtime_info_LOCATION_SERVICE_ENABLED_positive1(void)
1481 {
1482         char *TC_NAME = __FUNCTION__;
1483         int retcode;
1484         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED;
1485         bool value;
1486
1487         retcode = runtime_info_get_value_bool(key, &value);
1488
1489         if (retcode == RUNTIME_INFO_ERROR_NONE)
1490                 dts_pass(TC_NAME, "passed");
1491         else
1492                 dts_fail(TC_NAME, "failed");
1493 }
1494
1495 void utc_runtime_info_LOCATION_SERVICE_ENABLED_positive2(void)
1496 {
1497         char *TC_NAME = __FUNCTION__;
1498         int retcode;
1499         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED;
1500
1501         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1502
1503         if (retcode == RUNTIME_INFO_ERROR_NONE)
1504                 dts_pass(TC_NAME, "passed");
1505         else
1506                 dts_fail(TC_NAME, "failed");
1507 }
1508
1509 void utc_runtime_info_LOCATION_SERVICE_ENABLED_positive3(void)
1510 {
1511         char *TC_NAME = __FUNCTION__;
1512         int retcode;
1513         runtime_info_key_e key = RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED;
1514
1515         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1516
1517         retcode = runtime_info_unset_changed_cb(key);
1518
1519         if (retcode == RUNTIME_INFO_ERROR_NONE)
1520                 dts_pass(TC_NAME, "passed");
1521         else
1522                 dts_fail(TC_NAME, "failed");
1523 }
1524
1525 void utc_runtime_info_PACKET_DATA_ENABLED_negative1(void)
1526 {
1527         char *TC_NAME = __FUNCTION__;
1528         int retcode;
1529         runtime_info_key_e key = RUNTIME_INFO_KEY_PACKET_DATA_ENABLED;
1530         char *value;
1531
1532         retcode = runtime_info_get_value_string(key, &value);
1533
1534         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1535                 dts_pass(TC_NAME, "passed");
1536         else
1537                 dts_fail(TC_NAME, "failed");
1538 }
1539
1540
1541 void utc_runtime_info_PACKET_DATA_ENABLED_negative2(void)
1542 {
1543         char *TC_NAME = __FUNCTION__;
1544         int retcode;
1545         runtime_info_key_e key = RUNTIME_INFO_KEY_PACKET_DATA_ENABLED;
1546
1547         retcode = runtime_info_get_value_bool(key, NULL);
1548
1549         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1550                 dts_pass(TC_NAME, "passed");
1551         else
1552                 dts_fail(TC_NAME, "failed");
1553 }
1554
1555 void utc_runtime_info_PACKET_DATA_ENABLED_negative3(void)
1556 {
1557         char *TC_NAME = __FUNCTION__;
1558         int retcode;
1559         runtime_info_key_e key = RUNTIME_INFO_KEY_PACKET_DATA_ENABLED;
1560
1561         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1562
1563         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1564                 dts_pass(TC_NAME, "passed");
1565         else
1566                 dts_fail(TC_NAME, "failed");
1567 }
1568
1569 void utc_runtime_info_PACKET_DATA_ENABLED_positive1(void)
1570 {
1571         char *TC_NAME = __FUNCTION__;
1572         int retcode;
1573         runtime_info_key_e key = RUNTIME_INFO_KEY_PACKET_DATA_ENABLED;
1574         bool value;
1575
1576         retcode = runtime_info_get_value_bool(key, &value);
1577
1578         if (retcode == RUNTIME_INFO_ERROR_NONE)
1579                 dts_pass(TC_NAME, "passed");
1580         else
1581                 dts_fail(TC_NAME, "failed");
1582 }
1583
1584 void utc_runtime_info_PACKET_DATA_ENABLED_positive2(void)
1585 {
1586         char *TC_NAME = __FUNCTION__;
1587         int retcode;
1588         runtime_info_key_e key = RUNTIME_INFO_KEY_PACKET_DATA_ENABLED;
1589
1590         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1591
1592         if (retcode == RUNTIME_INFO_ERROR_NONE)
1593                 dts_pass(TC_NAME, "passed");
1594         else
1595                 dts_fail(TC_NAME, "failed");
1596 }
1597
1598 void utc_runtime_info_PACKET_DATA_ENABLED_positive3(void)
1599 {
1600         char *TC_NAME = __FUNCTION__;
1601         int retcode;
1602         runtime_info_key_e key = RUNTIME_INFO_KEY_PACKET_DATA_ENABLED;
1603
1604         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1605
1606         retcode = runtime_info_unset_changed_cb(key);
1607
1608         if (retcode == RUNTIME_INFO_ERROR_NONE)
1609                 dts_pass(TC_NAME, "passed");
1610         else
1611                 dts_fail(TC_NAME, "failed");
1612 }
1613
1614 void utc_runtime_info_REGION_negative1(void)
1615 {
1616         char *TC_NAME = __FUNCTION__;
1617         int retcode;
1618         runtime_info_key_e key = RUNTIME_INFO_KEY_REGION;
1619         bool value;
1620
1621         retcode = runtime_info_get_value_bool(key, &value);
1622
1623         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1624                 dts_pass(TC_NAME, "passed");
1625         else
1626                 dts_fail(TC_NAME, "failed");
1627 }
1628
1629 void utc_runtime_info_REGION_negative2(void)
1630 {
1631         char *TC_NAME = __FUNCTION__;
1632         int retcode;
1633         runtime_info_key_e key = RUNTIME_INFO_KEY_REGION;
1634
1635         retcode = runtime_info_get_value_string(key, NULL);
1636
1637         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1638                 dts_pass(TC_NAME, "passed");
1639         else
1640                 dts_fail(TC_NAME, "failed");
1641 }
1642
1643 void utc_runtime_info_REGION_negative3(void)
1644 {
1645         char *TC_NAME = __FUNCTION__;
1646         int retcode;
1647         runtime_info_key_e key = RUNTIME_INFO_KEY_REGION;
1648
1649         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1650
1651         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1652                 dts_pass(TC_NAME, "passed");
1653         else
1654                 dts_fail(TC_NAME, "failed");
1655 }
1656
1657 void utc_runtime_info_REGION_positive1(void)
1658 {
1659         char *TC_NAME = __FUNCTION__;
1660         int retcode;
1661         runtime_info_key_e key = RUNTIME_INFO_KEY_REGION;
1662         char *value;
1663
1664         retcode = runtime_info_get_value_string(key, &value);
1665
1666         if (retcode == RUNTIME_INFO_ERROR_NONE)
1667                 dts_pass(TC_NAME, "passed");
1668         else
1669                 dts_fail(TC_NAME, "failed");
1670 }
1671
1672 void utc_runtime_info_REGION_positive2(void)
1673 {
1674         char *TC_NAME = __FUNCTION__;
1675         int retcode;
1676         runtime_info_key_e key = RUNTIME_INFO_KEY_REGION;
1677
1678         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1679
1680         if (retcode == RUNTIME_INFO_ERROR_NONE)
1681                 dts_pass(TC_NAME, "passed");
1682         else
1683                 dts_fail(TC_NAME, "failed");
1684 }
1685
1686 void utc_runtime_info_REGION_positive3(void)
1687 {
1688         char *TC_NAME = __FUNCTION__;
1689         int retcode;
1690         runtime_info_key_e key = RUNTIME_INFO_KEY_REGION;
1691
1692         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1693
1694         retcode = runtime_info_unset_changed_cb(key);
1695
1696         if (retcode == RUNTIME_INFO_ERROR_NONE)
1697                 dts_pass(TC_NAME, "passed");
1698         else
1699                 dts_fail(TC_NAME, "failed");
1700 }
1701
1702 void utc_runtime_info_AUTO_ROTATION_ENABLED_negative1(void)
1703 {
1704         char *TC_NAME = __FUNCTION__;
1705         int retcode;
1706         runtime_info_key_e key = RUNTIME_INFO_KEY_AUTO_ROTATION_ENABLED;
1707         char *value;
1708
1709         retcode = runtime_info_get_value_string(key, &value);
1710
1711         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1712                 dts_pass(TC_NAME, "passed");
1713         else
1714                 dts_fail(TC_NAME, "failed");
1715 }
1716
1717 void utc_runtime_info_AUTO_ROTATION_ENABLED_negative2(void)
1718 {
1719         char *TC_NAME = __FUNCTION__;
1720         int retcode;
1721         runtime_info_key_e key = RUNTIME_INFO_KEY_AUTO_ROTATION_ENABLED;
1722
1723         retcode = runtime_info_get_value_bool(key, NULL);
1724
1725         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1726                 dts_pass(TC_NAME, "passed");
1727         else
1728                 dts_fail(TC_NAME, "failed");
1729 }
1730
1731 void utc_runtime_info_AUTO_ROTATION_ENABLED_negative3(void)
1732 {
1733         char *TC_NAME = __FUNCTION__;
1734         int retcode;
1735         runtime_info_key_e key = RUNTIME_INFO_KEY_AUTO_ROTATION_ENABLED;
1736
1737         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1738
1739         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1740                 dts_pass(TC_NAME, "passed");
1741         else
1742                 dts_fail(TC_NAME, "failed");
1743 }
1744
1745 void utc_runtime_info_AUTO_ROTATION_ENABLED_positive1(void)
1746 {
1747         char *TC_NAME = __FUNCTION__;
1748         int retcode;
1749         runtime_info_key_e key = RUNTIME_INFO_KEY_AUTO_ROTATION_ENABLED;
1750         bool value;
1751
1752         retcode = runtime_info_get_value_bool(key, &value);
1753
1754         if (retcode == RUNTIME_INFO_ERROR_NONE)
1755                 dts_pass(TC_NAME, "passed");
1756         else
1757                 dts_fail(TC_NAME, "failed");
1758 }
1759
1760 void utc_runtime_info_AUTO_ROTATION_ENABLED_positive2(void)
1761 {
1762         char *TC_NAME = __FUNCTION__;
1763         int retcode;
1764         runtime_info_key_e key = RUNTIME_INFO_KEY_AUTO_ROTATION_ENABLED;
1765
1766         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1767
1768         if (retcode == RUNTIME_INFO_ERROR_NONE)
1769                 dts_pass(TC_NAME, "passed");
1770         else
1771                 dts_fail(TC_NAME, "failed");
1772 }
1773
1774 void utc_runtime_info_AUTO_ROTATION_ENABLED_positive3(void)
1775 {
1776         char *TC_NAME = __FUNCTION__;
1777         int retcode;
1778         runtime_info_key_e key = RUNTIME_INFO_KEY_AUTO_ROTATION_ENABLED;
1779
1780         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1781
1782         retcode = runtime_info_unset_changed_cb(key);
1783
1784         if (retcode == RUNTIME_INFO_ERROR_NONE)
1785                 dts_pass(TC_NAME, "passed");
1786         else
1787                 dts_fail(TC_NAME, "failed");
1788 }
1789
1790 void utc_runtime_info_SILENT_MODE_ENABLED_negative1(void)
1791 {
1792         char *TC_NAME = __FUNCTION__;
1793         int retcode;
1794         runtime_info_key_e key = RUNTIME_INFO_KEY_SILENT_MODE_ENABLED;
1795         char *value;
1796
1797         retcode = runtime_info_get_value_string(key, &value);
1798
1799         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1800                 dts_pass(TC_NAME, "passed");
1801         else
1802                 dts_fail(TC_NAME, "failed");
1803 }
1804
1805 void utc_runtime_info_SILENT_MODE_ENABLED_negative2(void)
1806 {
1807         char *TC_NAME = __FUNCTION__;
1808         int retcode;
1809         runtime_info_key_e key = RUNTIME_INFO_KEY_SILENT_MODE_ENABLED;
1810
1811         retcode = runtime_info_get_value_bool(key, NULL);
1812
1813         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1814                 dts_pass(TC_NAME, "passed");
1815         else
1816                 dts_fail(TC_NAME, "failed");
1817 }
1818
1819 void utc_runtime_info_SILENT_MODE_ENABLED_negative3(void)
1820 {
1821         char *TC_NAME = __FUNCTION__;
1822         int retcode;
1823         runtime_info_key_e key = RUNTIME_INFO_KEY_SILENT_MODE_ENABLED;
1824
1825         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1826
1827         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1828                 dts_pass(TC_NAME, "passed");
1829         else
1830                 dts_fail(TC_NAME, "failed");
1831 }
1832
1833 void utc_runtime_info_SILENT_MODE_ENABLED_positive1(void)
1834 {
1835         char *TC_NAME = __FUNCTION__;
1836         int retcode;
1837         runtime_info_key_e key = RUNTIME_INFO_KEY_SILENT_MODE_ENABLED;
1838         bool value;
1839
1840         retcode = runtime_info_get_value_bool(key, &value);
1841
1842         if (retcode == RUNTIME_INFO_ERROR_NONE)
1843                 dts_pass(TC_NAME, "passed");
1844         else
1845                 dts_fail(TC_NAME, "failed");
1846 }
1847
1848 void utc_runtime_info_SILENT_MODE_ENABLED_positive2(void)
1849 {
1850         char *TC_NAME = __FUNCTION__;
1851         int retcode;
1852         runtime_info_key_e key = RUNTIME_INFO_KEY_SILENT_MODE_ENABLED;
1853
1854         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1855
1856         if (retcode == RUNTIME_INFO_ERROR_NONE)
1857                 dts_pass(TC_NAME, "passed");
1858         else
1859                 dts_fail(TC_NAME, "failed");
1860 }
1861
1862 void utc_runtime_info_SILENT_MODE_ENABLED_positive3(void)
1863 {
1864         char *TC_NAME = __FUNCTION__;
1865         int retcode;
1866         runtime_info_key_e key = RUNTIME_INFO_KEY_SILENT_MODE_ENABLED;
1867
1868         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1869
1870         retcode = runtime_info_unset_changed_cb(key);
1871
1872         if (retcode == RUNTIME_INFO_ERROR_NONE)
1873                 dts_pass(TC_NAME, "passed");
1874         else
1875                 dts_fail(TC_NAME, "failed");
1876 }
1877
1878 void utc_runtime_info_USB_TETHERING_ENABLED_negative1(void)
1879 {
1880         char *TC_NAME = __FUNCTION__;
1881         int retcode;
1882         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_TETHERING_ENABLED;
1883         char *value;
1884
1885         retcode = runtime_info_get_value_string(key, &value);
1886
1887         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1888                 dts_pass(TC_NAME, "passed");
1889         else
1890                 dts_fail(TC_NAME, "failed");
1891 }
1892
1893 void utc_runtime_info_USB_TETHERING_ENABLED_negative2(void)
1894 {
1895         char *TC_NAME = __FUNCTION__;
1896         int retcode;
1897         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_TETHERING_ENABLED;
1898
1899         retcode = runtime_info_get_value_bool(key, NULL);
1900
1901         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1902                 dts_pass(TC_NAME, "passed");
1903         else
1904                 dts_fail(TC_NAME, "failed");
1905 }
1906
1907 void utc_runtime_info_USB_TETHERING_ENABLED_negative3(void)
1908 {
1909         char *TC_NAME = __FUNCTION__;
1910         int retcode;
1911         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_TETHERING_ENABLED;
1912
1913         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
1914
1915         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1916                 dts_pass(TC_NAME, "passed");
1917         else
1918                 dts_fail(TC_NAME, "failed");
1919 }
1920
1921 void utc_runtime_info_USB_TETHERING_ENABLED_positive1(void)
1922 {
1923         char *TC_NAME = __FUNCTION__;
1924         int retcode;
1925         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_TETHERING_ENABLED;
1926         bool value;
1927
1928         retcode = runtime_info_get_value_bool(key, &value);
1929
1930         if (retcode == RUNTIME_INFO_ERROR_NONE)
1931                 dts_pass(TC_NAME, "passed");
1932         else
1933                 dts_fail(TC_NAME, "failed");
1934 }
1935
1936 void utc_runtime_info_USB_TETHERING_ENABLED_positive2(void)
1937 {
1938         char *TC_NAME = __FUNCTION__;
1939         int retcode;
1940         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_TETHERING_ENABLED;
1941
1942         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1943
1944         if (retcode == RUNTIME_INFO_ERROR_NONE)
1945                 dts_pass(TC_NAME, "passed");
1946         else
1947                 dts_fail(TC_NAME, "failed");
1948 }
1949
1950 void utc_runtime_info_USB_TETHERING_ENABLED_positive3(void)
1951 {
1952         char *TC_NAME = __FUNCTION__;
1953         int retcode;
1954         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_TETHERING_ENABLED;
1955
1956         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
1957
1958         retcode = runtime_info_unset_changed_cb(key);
1959
1960         if (retcode == RUNTIME_INFO_ERROR_NONE)
1961                 dts_pass(TC_NAME, "passed");
1962         else
1963                 dts_fail(TC_NAME, "failed");
1964 }
1965
1966 void utc_runtime_info_VIBRATION_ENABLED_negative1(void)
1967 {
1968         char *TC_NAME = __FUNCTION__;
1969         int retcode;
1970         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_ENABLED;
1971         char *value;
1972
1973         retcode = runtime_info_get_value_string(key, &value);
1974
1975         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1976                 dts_pass(TC_NAME, "passed");
1977         else
1978                 dts_fail(TC_NAME, "failed");
1979 }
1980
1981 void utc_runtime_info_VIBRATION_ENABLED_negative2(void)
1982 {
1983         char *TC_NAME = __FUNCTION__;
1984         int retcode;
1985         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_ENABLED;
1986
1987         retcode = runtime_info_get_value_bool(key, NULL);
1988
1989         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
1990                 dts_pass(TC_NAME, "passed");
1991         else
1992                 dts_fail(TC_NAME, "failed");
1993 }
1994
1995 void utc_runtime_info_VIBRATION_ENABLED_negative3(void)
1996 {
1997         char *TC_NAME = __FUNCTION__;
1998         int retcode;
1999         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_ENABLED;
2000
2001         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2002
2003         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2004                 dts_pass(TC_NAME, "passed");
2005         else
2006                 dts_fail(TC_NAME, "failed");
2007 }
2008
2009 void utc_runtime_info_VIBRATION_ENABLED_positive1(void)
2010 {
2011         char *TC_NAME = __FUNCTION__;
2012         int retcode;
2013         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_ENABLED;
2014         bool value;
2015
2016         retcode = runtime_info_get_value_bool(key, &value);
2017
2018         if (retcode == RUNTIME_INFO_ERROR_NONE)
2019                 dts_pass(TC_NAME, "passed");
2020         else
2021                 dts_fail(TC_NAME, "failed");
2022 }
2023
2024 void utc_runtime_info_VIBRATION_ENABLED_positive2(void)
2025 {
2026         char *TC_NAME = __FUNCTION__;
2027         int retcode;
2028         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_ENABLED;
2029
2030         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2031
2032         if (retcode == RUNTIME_INFO_ERROR_NONE)
2033                 dts_pass(TC_NAME, "passed");
2034         else
2035                 dts_fail(TC_NAME, "failed");
2036 }
2037
2038 void utc_runtime_info_VIBRATION_ENABLED_positive3(void)
2039 {
2040         char *TC_NAME = __FUNCTION__;
2041         int retcode;
2042         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_ENABLED;
2043
2044         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2045
2046         retcode = runtime_info_unset_changed_cb(key);
2047
2048         if (retcode == RUNTIME_INFO_ERROR_NONE)
2049                 dts_pass(TC_NAME, "passed");
2050         else
2051                 dts_fail(TC_NAME, "failed");
2052 }
2053
2054 void utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative1(void)
2055 {
2056         char *TC_NAME = __FUNCTION__;
2057         int retcode;
2058         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_HOTSPOT_ENABLED;
2059         char *value;
2060
2061         retcode = runtime_info_get_value_string(key, &value);
2062
2063         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2064                 dts_pass(TC_NAME, "passed");
2065         else
2066                 dts_fail(TC_NAME, "failed");
2067 }
2068
2069 void utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative2(void)
2070 {
2071         char *TC_NAME = __FUNCTION__;
2072         int retcode;
2073         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_HOTSPOT_ENABLED;
2074
2075         retcode = runtime_info_get_value_bool(key, NULL);
2076
2077         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2078                 dts_pass(TC_NAME, "passed");
2079         else
2080                 dts_fail(TC_NAME, "failed");
2081 }
2082
2083 void utc_runtime_info_WIFI_HOTSPOT_ENABLED_negative3(void)
2084 {
2085         char *TC_NAME = __FUNCTION__;
2086         int retcode;
2087         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_HOTSPOT_ENABLED;
2088
2089         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2090
2091         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2092                 dts_pass(TC_NAME, "passed");
2093         else
2094                 dts_fail(TC_NAME, "failed");
2095 }
2096
2097 void utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive1(void)
2098 {
2099         char *TC_NAME = __FUNCTION__;
2100         int retcode;
2101         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_HOTSPOT_ENABLED;
2102         bool value;
2103
2104         retcode = runtime_info_get_value_bool(key, &value);
2105
2106         if (retcode == RUNTIME_INFO_ERROR_NONE)
2107                 dts_pass(TC_NAME, "passed");
2108         else
2109                 dts_fail(TC_NAME, "failed");
2110 }
2111
2112 void utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive2(void)
2113 {
2114         char *TC_NAME = __FUNCTION__;
2115         int retcode;
2116         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_HOTSPOT_ENABLED;
2117
2118         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2119
2120         if (retcode == RUNTIME_INFO_ERROR_NONE)
2121                 dts_pass(TC_NAME, "passed");
2122         else
2123                 dts_fail(TC_NAME, "failed");
2124 }
2125
2126 void utc_runtime_info_WIFI_HOTSPOT_ENABLED_positive3(void)
2127 {
2128         char *TC_NAME = __FUNCTION__;
2129         int retcode;
2130         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_HOTSPOT_ENABLED;
2131
2132         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2133
2134         retcode = runtime_info_unset_changed_cb(key);
2135
2136         if (retcode == RUNTIME_INFO_ERROR_NONE)
2137                 dts_pass(TC_NAME, "passed");
2138         else
2139                 dts_fail(TC_NAME, "failed");
2140 }
2141
2142 void utc_runtime_info_WIFI_STATUS_negative1(void)
2143 {
2144         char *TC_NAME = __FUNCTION__;
2145         int retcode;
2146         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_STATUS;
2147         char *value;
2148
2149         retcode = runtime_info_get_value_string(key, &value);
2150
2151         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2152                 dts_pass(TC_NAME, "passed");
2153         else
2154                 dts_fail(TC_NAME, "failed");
2155 }
2156
2157 void utc_runtime_info_WIFI_STATUS_negative2(void)
2158 {
2159         char *TC_NAME = __FUNCTION__;
2160         int retcode;
2161         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_STATUS;
2162
2163         retcode = runtime_info_get_value_int(key, NULL);
2164
2165         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2166                 dts_pass(TC_NAME, "passed");
2167         else
2168                 dts_fail(TC_NAME, "failed");
2169 }
2170
2171 void utc_runtime_info_WIFI_STATUS_negative3(void)
2172 {
2173         char *TC_NAME = __FUNCTION__;
2174         int retcode;
2175         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_STATUS;
2176
2177         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2178
2179         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2180                 dts_pass(TC_NAME, "passed");
2181         else
2182                 dts_fail(TC_NAME, "failed");
2183 }
2184
2185 void utc_runtime_info_WIFI_STATUS_positive1(void)
2186 {
2187         char *TC_NAME = __FUNCTION__;
2188         int retcode;
2189         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_STATUS;
2190         int value;
2191
2192         retcode = runtime_info_get_value_int(key, &value);
2193
2194         if (retcode == RUNTIME_INFO_ERROR_NONE)
2195                 dts_pass(TC_NAME, "passed");
2196         else
2197                 dts_fail(TC_NAME, "failed");
2198 }
2199
2200 void utc_runtime_info_WIFI_STATUS_positive2(void)
2201 {
2202         char *TC_NAME = __FUNCTION__;
2203         int retcode;
2204         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_STATUS;
2205
2206         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2207
2208         if (retcode == RUNTIME_INFO_ERROR_NONE)
2209                 dts_pass(TC_NAME, "passed");
2210         else
2211                 dts_fail(TC_NAME, "failed");
2212 }
2213
2214 void utc_runtime_info_WIFI_STATUS_positive3(void)
2215 {
2216         char *TC_NAME = __FUNCTION__;
2217         int retcode;
2218         runtime_info_key_e key = RUNTIME_INFO_KEY_WIFI_STATUS;
2219
2220         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2221
2222         retcode = runtime_info_unset_changed_cb(key);
2223
2224         if (retcode == RUNTIME_INFO_ERROR_NONE)
2225                 dts_pass(TC_NAME, "passed");
2226         else
2227                 dts_fail(TC_NAME, "failed");
2228 }
2229
2230 void utc_runtime_info_TV_OUT_CONNECTED_negative1(void)
2231 {
2232         char *TC_NAME = __FUNCTION__;
2233         int retcode;
2234         runtime_info_key_e key = RUNTIME_INFO_KEY_TV_OUT_CONNECTED;
2235         char *value;
2236
2237         retcode = runtime_info_get_value_string(key, &value);
2238
2239         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2240                 dts_pass(TC_NAME, "passed");
2241         else
2242                 dts_fail(TC_NAME, "failed");
2243 }
2244
2245 void utc_runtime_info_TV_OUT_CONNECTED_negative2(void)
2246 {
2247         char *TC_NAME = __FUNCTION__;
2248         int retcode;
2249         runtime_info_key_e key = RUNTIME_INFO_KEY_TV_OUT_CONNECTED;
2250
2251         retcode = runtime_info_get_value_bool(key, NULL);
2252
2253         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2254                 dts_pass(TC_NAME, "passed");
2255         else
2256                 dts_fail(TC_NAME, "failed");
2257 }
2258
2259 void utc_runtime_info_TV_OUT_CONNECTED_negative3(void)
2260 {
2261         char *TC_NAME = __FUNCTION__;
2262         int retcode;
2263         runtime_info_key_e key = RUNTIME_INFO_KEY_TV_OUT_CONNECTED;
2264
2265         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2266
2267         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2268                 dts_pass(TC_NAME, "passed");
2269         else
2270                 dts_fail(TC_NAME, "failed");
2271 }
2272
2273 void utc_runtime_info_TV_OUT_CONNECTED_positive1(void)
2274 {
2275         char *TC_NAME = __FUNCTION__;
2276         int retcode;
2277         runtime_info_key_e key = RUNTIME_INFO_KEY_TV_OUT_CONNECTED;
2278         bool value;
2279
2280         retcode = runtime_info_get_value_bool(key, &value);
2281
2282         if (retcode == RUNTIME_INFO_ERROR_NONE)
2283                 dts_pass(TC_NAME, "passed");
2284         else
2285                 dts_fail(TC_NAME, "failed");
2286 }
2287
2288 void utc_runtime_info_TV_OUT_CONNECTED_positive2(void)
2289 {
2290         char *TC_NAME = __FUNCTION__;
2291         int retcode;
2292         runtime_info_key_e key = RUNTIME_INFO_KEY_TV_OUT_CONNECTED;
2293
2294         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2295
2296         if (retcode == RUNTIME_INFO_ERROR_NONE)
2297                 dts_pass(TC_NAME, "passed");
2298         else
2299                 dts_fail(TC_NAME, "failed");
2300 }
2301
2302 void utc_runtime_info_TV_OUT_CONNECTED_positive3(void)
2303 {
2304         char *TC_NAME = __FUNCTION__;
2305         int retcode;
2306         runtime_info_key_e key = RUNTIME_INFO_KEY_TV_OUT_CONNECTED;
2307
2308         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2309
2310         retcode = runtime_info_unset_changed_cb(key);
2311
2312         if (retcode == RUNTIME_INFO_ERROR_NONE)
2313                 dts_pass(TC_NAME, "passed");
2314         else
2315                 dts_fail(TC_NAME, "failed");
2316 }
2317
2318 void utc_runtime_info_AUDIO_JACK_STATUS_negative1(void)
2319 {
2320         char *TC_NAME = __FUNCTION__;
2321         int retcode;
2322         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_STATUS;
2323         char *value;
2324
2325         retcode = runtime_info_get_value_string(key, &value);
2326
2327         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2328                 dts_pass(TC_NAME, "passed");
2329         else
2330                 dts_fail(TC_NAME, "failed");
2331 }
2332
2333 void utc_runtime_info_AUDIO_JACK_STATUS_negative2(void)
2334 {
2335         char *TC_NAME = __FUNCTION__;
2336         int retcode;
2337         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_STATUS;
2338
2339         retcode = runtime_info_get_value_int(key, NULL);
2340
2341         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2342                 dts_pass(TC_NAME, "passed");
2343         else
2344                 dts_fail(TC_NAME, "failed");
2345 }
2346
2347 void utc_runtime_info_AUDIO_JACK_STATUS_negative3(void)
2348 {
2349         char *TC_NAME = __FUNCTION__;
2350         int retcode;
2351         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_STATUS;
2352
2353         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2354
2355         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2356                 dts_pass(TC_NAME, "passed");
2357         else
2358                 dts_fail(TC_NAME, "failed");
2359 }
2360
2361 void utc_runtime_info_AUDIO_JACK_STATUS_positive1(void)
2362 {
2363         char *TC_NAME = __FUNCTION__;
2364         int retcode;
2365         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_STATUS;
2366         int value;
2367
2368         retcode = runtime_info_get_value_int(key, &value);
2369
2370         if (retcode == RUNTIME_INFO_ERROR_NONE)
2371                 dts_pass(TC_NAME, "passed");
2372         else
2373                 dts_fail(TC_NAME, "failed");
2374 }
2375
2376 void utc_runtime_info_AUDIO_JACK_STATUS_positive2(void)
2377 {
2378         char *TC_NAME = __FUNCTION__;
2379         int retcode;
2380         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_STATUS;
2381
2382         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2383
2384         if (retcode == RUNTIME_INFO_ERROR_NONE)
2385                 dts_pass(TC_NAME, "passed");
2386         else
2387                 dts_fail(TC_NAME, "failed");
2388 }
2389
2390 void utc_runtime_info_AUDIO_JACK_STATUS_positive3(void)
2391 {
2392         char *TC_NAME = __FUNCTION__;
2393         int retcode;
2394         runtime_info_key_e key = RUNTIME_INFO_KEY_AUDIO_JACK_STATUS;
2395
2396         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2397
2398         retcode = runtime_info_unset_changed_cb(key);
2399
2400         if (retcode == RUNTIME_INFO_ERROR_NONE)
2401                 dts_pass(TC_NAME, "passed");
2402         else
2403                 dts_fail(TC_NAME, "failed");
2404 }
2405
2406 void utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative1(void)
2407 {
2408         char *TC_NAME = __FUNCTION__;
2409         int retcode;
2410         runtime_info_key_e key = RUNTIME_INFO_KEY_SLIDING_KEYBOARD_OPENED;
2411         char *value;
2412
2413         retcode = runtime_info_get_value_string(key, &value);
2414
2415         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2416                 dts_pass(TC_NAME, "passed");
2417         else
2418                 dts_fail(TC_NAME, "failed");
2419 }
2420
2421 void utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative2(void)
2422 {
2423         char *TC_NAME = __FUNCTION__;
2424         int retcode;
2425         runtime_info_key_e key = RUNTIME_INFO_KEY_SLIDING_KEYBOARD_OPENED;
2426
2427         retcode = runtime_info_get_value_bool(key, NULL);
2428
2429         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2430                 dts_pass(TC_NAME, "passed");
2431         else
2432                 dts_fail(TC_NAME, "failed");
2433 }
2434
2435 void utc_runtime_info_SLIDING_KEYBOARD_OPENED_negative3(void)
2436 {
2437         char *TC_NAME = __FUNCTION__;
2438         int retcode;
2439         runtime_info_key_e key = RUNTIME_INFO_KEY_SLIDING_KEYBOARD_OPENED;
2440
2441         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2442
2443         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2444                 dts_pass(TC_NAME, "passed");
2445         else
2446                 dts_fail(TC_NAME, "failed");
2447 }
2448
2449 void utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive1(void)
2450 {
2451         char *TC_NAME = __FUNCTION__;
2452         int retcode;
2453         runtime_info_key_e key = RUNTIME_INFO_KEY_SLIDING_KEYBOARD_OPENED;
2454         bool value;
2455
2456         retcode = runtime_info_get_value_bool(key, &value);
2457
2458         if (retcode == RUNTIME_INFO_ERROR_NONE)
2459                 dts_pass(TC_NAME, "passed");
2460         else
2461                 dts_fail(TC_NAME, "failed");
2462 }
2463
2464 void utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive2(void)
2465 {
2466         char *TC_NAME = __FUNCTION__;
2467         int retcode;
2468         runtime_info_key_e key = RUNTIME_INFO_KEY_SLIDING_KEYBOARD_OPENED;
2469
2470         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2471
2472         if (retcode == RUNTIME_INFO_ERROR_NONE)
2473                 dts_pass(TC_NAME, "passed");
2474         else
2475                 dts_fail(TC_NAME, "failed");
2476 }
2477
2478 void utc_runtime_info_SLIDING_KEYBOARD_OPENED_positive3(void)
2479 {
2480         char *TC_NAME = __FUNCTION__;
2481         int retcode;
2482         runtime_info_key_e key = RUNTIME_INFO_KEY_SLIDING_KEYBOARD_OPENED;
2483
2484         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2485
2486         retcode = runtime_info_unset_changed_cb(key);
2487
2488         if (retcode == RUNTIME_INFO_ERROR_NONE)
2489                 dts_pass(TC_NAME, "passed");
2490         else
2491                 dts_fail(TC_NAME, "failed");
2492 }
2493
2494 void utc_runtime_info_USB_CONNECTED_negative1(void)
2495 {
2496         char *TC_NAME = __FUNCTION__;
2497         int retcode;
2498         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_CONNECTED;
2499         char *value;
2500
2501         retcode = runtime_info_get_value_string(key, &value);
2502
2503         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2504                 dts_pass(TC_NAME, "passed");
2505         else
2506                 dts_fail(TC_NAME, "failed");
2507 }
2508
2509 void utc_runtime_info_USB_CONNECTED_negative2(void)
2510 {
2511         char *TC_NAME = __FUNCTION__;
2512         int retcode;
2513         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_CONNECTED;
2514
2515         retcode = runtime_info_get_value_bool(key, NULL);
2516
2517         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2518                 dts_pass(TC_NAME, "passed");
2519         else
2520                 dts_fail(TC_NAME, "failed");
2521 }
2522
2523 void utc_runtime_info_USB_CONNECTED_negative3(void)
2524 {
2525         char *TC_NAME = __FUNCTION__;
2526         int retcode;
2527         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_CONNECTED;
2528
2529         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2530
2531         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2532                 dts_pass(TC_NAME, "passed");
2533         else
2534                 dts_fail(TC_NAME, "failed");
2535 }
2536
2537 void utc_runtime_info_USB_CONNECTED_positive1(void)
2538 {
2539         char *TC_NAME = __FUNCTION__;
2540         int retcode;
2541         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_CONNECTED;
2542         bool value;
2543
2544         retcode = runtime_info_get_value_bool(key, &value);
2545
2546         if (retcode == RUNTIME_INFO_ERROR_NONE)
2547                 dts_pass(TC_NAME, "passed");
2548         else
2549                 dts_fail(TC_NAME, "failed");
2550 }
2551
2552 void utc_runtime_info_USB_CONNECTED_positive2(void)
2553 {
2554         char *TC_NAME = __FUNCTION__;
2555         int retcode;
2556         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_CONNECTED;
2557
2558         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2559
2560         if (retcode == RUNTIME_INFO_ERROR_NONE)
2561                 dts_pass(TC_NAME, "passed");
2562         else
2563                 dts_fail(TC_NAME, "failed");
2564 }
2565
2566 void utc_runtime_info_USB_CONNECTED_positive3(void)
2567 {
2568         char *TC_NAME = __FUNCTION__;
2569         int retcode;
2570         runtime_info_key_e key = RUNTIME_INFO_KEY_USB_CONNECTED;
2571
2572         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2573
2574         retcode = runtime_info_unset_changed_cb(key);
2575
2576         if (retcode == RUNTIME_INFO_ERROR_NONE)
2577                 dts_pass(TC_NAME, "passed");
2578         else
2579                 dts_fail(TC_NAME, "failed");
2580 }
2581
2582 void utc_runtime_info_CHARGER_CONNECTED_negative1(void)
2583 {
2584         char *TC_NAME = __FUNCTION__;
2585         int retcode;
2586         runtime_info_key_e key = RUNTIME_INFO_KEY_CHARGER_CONNECTED;
2587         char *value;
2588
2589         retcode = runtime_info_get_value_string(key, &value);
2590
2591         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2592                 dts_pass(TC_NAME, "passed");
2593         else
2594                 dts_fail(TC_NAME, "failed");
2595 }
2596
2597 void utc_runtime_info_CHARGER_CONNECTED_negative2(void)
2598 {
2599         char *TC_NAME = __FUNCTION__;
2600         int retcode;
2601         runtime_info_key_e key = RUNTIME_INFO_KEY_CHARGER_CONNECTED;
2602
2603         retcode = runtime_info_get_value_bool(key, NULL);
2604
2605         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2606                 dts_pass(TC_NAME, "passed");
2607         else
2608                 dts_fail(TC_NAME, "failed");
2609 }
2610
2611 void utc_runtime_info_CHARGER_CONNECTED_negative3(void)
2612 {
2613         char *TC_NAME = __FUNCTION__;
2614         int retcode;
2615         runtime_info_key_e key = RUNTIME_INFO_KEY_CHARGER_CONNECTED;
2616
2617         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2618
2619         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2620                 dts_pass(TC_NAME, "passed");
2621         else
2622                 dts_fail(TC_NAME, "failed");
2623 }
2624
2625 void utc_runtime_info_CHARGER_CONNECTED_positive1(void)
2626 {
2627         char *TC_NAME = __FUNCTION__;
2628         int retcode;
2629         runtime_info_key_e key = RUNTIME_INFO_KEY_CHARGER_CONNECTED;
2630         bool value;
2631
2632         retcode = runtime_info_get_value_bool(key, &value);
2633
2634         if (retcode == RUNTIME_INFO_ERROR_NONE)
2635                 dts_pass(TC_NAME, "passed");
2636         else
2637                 dts_fail(TC_NAME, "failed");
2638 }
2639
2640 void utc_runtime_info_CHARGER_CONNECTED_positive2(void)
2641 {
2642         char *TC_NAME = __FUNCTION__;
2643         int retcode;
2644         runtime_info_key_e key = RUNTIME_INFO_KEY_CHARGER_CONNECTED;
2645
2646         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2647
2648         if (retcode == RUNTIME_INFO_ERROR_NONE)
2649                 dts_pass(TC_NAME, "passed");
2650         else
2651                 dts_fail(TC_NAME, "failed");
2652 }
2653
2654 void utc_runtime_info_CHARGER_CONNECTED_positive3(void)
2655 {
2656         char *TC_NAME = __FUNCTION__;
2657         int retcode;
2658         runtime_info_key_e key = RUNTIME_INFO_KEY_CHARGER_CONNECTED;
2659
2660         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2661
2662         retcode = runtime_info_unset_changed_cb(key);
2663
2664         if (retcode == RUNTIME_INFO_ERROR_NONE)
2665                 dts_pass(TC_NAME, "passed");
2666         else
2667                 dts_fail(TC_NAME, "failed");
2668 }
2669
2670 void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative1(void)
2671 {
2672         char *TC_NAME = __FUNCTION__;
2673         int retcode;
2674         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK;
2675         char *value;
2676
2677         retcode = runtime_info_get_value_string(key, &value);
2678
2679         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2680                 dts_pass(TC_NAME, "passed");
2681         else
2682                 dts_fail(TC_NAME, "failed");
2683 }
2684
2685 void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative2(void)
2686 {
2687         char *TC_NAME = __FUNCTION__;
2688         int retcode;
2689         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK;
2690
2691         retcode = runtime_info_get_value_int(key, NULL);
2692
2693         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2694                 dts_pass(TC_NAME, "passed");
2695         else
2696                 dts_fail(TC_NAME, "failed");
2697 }
2698
2699 void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_negative3(void)
2700 {
2701         char *TC_NAME = __FUNCTION__;
2702         int retcode;
2703         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK;
2704
2705         retcode = runtime_info_set_changed_cb(key, NULL, NULL);
2706
2707         if (retcode == RUNTIME_INFO_ERROR_INVALID_PARAMETER)
2708                 dts_pass(TC_NAME, "passed");
2709         else
2710                 dts_fail(TC_NAME, "failed");
2711 }
2712
2713 void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive1(void)
2714 {
2715         char *TC_NAME = __FUNCTION__;
2716         int retcode;
2717         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK;
2718         int value;
2719
2720         retcode = runtime_info_get_value_int(key, &value);
2721
2722         if (retcode == RUNTIME_INFO_ERROR_NONE)
2723                 dts_pass(TC_NAME, "passed");
2724         else
2725                 dts_fail(TC_NAME, "failed");
2726 }
2727
2728 void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive2(void)
2729 {
2730         char *TC_NAME = __FUNCTION__;
2731         int retcode;
2732         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK;
2733
2734         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2735
2736         if (retcode == RUNTIME_INFO_ERROR_NONE)
2737                 dts_pass(TC_NAME, "passed");
2738         else
2739                 dts_fail(TC_NAME, "failed");
2740 }
2741
2742 void utc_runtime_info_VIBRATION_LEVEL_HAPTIC_FEEDBACK_positive3(void)
2743 {
2744         char *TC_NAME = __FUNCTION__;
2745         int retcode;
2746         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK;
2747
2748         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2749
2750         retcode = runtime_info_unset_changed_cb(key);
2751
2752         if (retcode == RUNTIME_INFO_ERROR_NONE)
2753                 dts_pass(TC_NAME, "passed");
2754         else
2755                 dts_fail(TC_NAME, "failed");
2756 }
2757
2758 static void utc_runtime_info_set_changed_cb(void)
2759 {
2760         char *TC_NAME = __FUNCTION__;
2761         int retcode;
2762         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK;
2763
2764         retcode = runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2765
2766         runtime_info_unset_changed_cb(key);
2767
2768         if (retcode == RUNTIME_INFO_ERROR_NONE)
2769                 dts_pass(TC_NAME, "passed");
2770         else
2771                 dts_fail(TC_NAME, "failed");
2772 }
2773
2774 static void utc_runtime_info_unset_changed_cb(void)
2775 {
2776         char *TC_NAME = __FUNCTION__;
2777         int retcode;
2778         runtime_info_key_e key = RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK;
2779
2780         runtime_info_set_changed_cb(key, runtime_info_changed, NULL);
2781
2782         retcode = runtime_info_unset_changed_cb(key);
2783
2784         if (retcode == RUNTIME_INFO_ERROR_NONE)
2785                 dts_pass(TC_NAME, "passed");
2786         else
2787                 dts_fail(TC_NAME, "failed");
2788 }