src/auto-test/brightness.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <unistd.h>
   4 #include <stdlib.h>
   5
   6 #include <vconf.h>
   7
   8 #include "test.h"
   9
  10 #define CMD_INTERVAL_SEC                1       /* second */
  11 #define CMD_LONG_INTERVAL_SEC   3       /* second */
  12
  13 #define print_command(command) \
  14         do {\
  15                 printf("%12s | ", command); \
  16                 fflush(stdout); \
  17                 sleep(CMD_INTERVAL_SEC); \
  18         } while(0)
  19
  20 extern void battery_scenario(char *unit, int status);
  21
  22 static bool tc_success;
  23 static int success, fail;
  24
  25 static void start_udev(void)
  26 {
  27         dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
  28                         DEVICED_PATH_SYSNOTI,
  29                         DEVICED_INTERFACE_SYSNOTI,
  30                         "udev",
  31                         g_variant_new("(sis)", "udev", 1, "start"),
  32                         NULL);
  33 }
  34
  35 static void stop_udev(void)
  36 {
  37         dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
  38                         DEVICED_PATH_SYSNOTI,
  39                         DEVICED_INTERFACE_SYSNOTI,
  40                         "udev",
  41                         g_variant_new("(sis)", "udev", 1, "stop"),
  42                         NULL);
  43 }
  44
  45 static int call_display_method_sync(const char *method, GVariant *param)
  46 {
  47         int ret_dbus;
  48         ret_dbus = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
  49                         DEVICED_PATH_DISPLAY,
  50                         DEVICED_INTERFACE_DISPLAY,
  51                         method, param, NULL);
  52         if (ret_dbus < 0) {
  53                 _E("Failed to %s.", method);
  54                 return -1;
  55         }
  56
  57         return 0;
  58 }
  59
  60 static void check_result(int expect_default, int expect_current)
  61 {
  62         int ret_dbus;
  63         int reply_default;
  64         int reply_current;
  65         bool match_default;
  66         bool match_current;
  67         GVariant *reply;
  68
  69         ret_dbus = dbus_handle_method_sync_with_reply_var(DEVICED_BUS_NAME,
  70                         DEVICED_PATH_DISPLAY,
  71                         DEVICED_INTERFACE_DISPLAY,
  72                         "GetBrightnessInfo", NULL, &reply);
  73         if (ret_dbus < 0) {
  74                 _E("Failed to GetBrightnessInfo.");
  75                 return;
  76         }
  77
  78         if (!g_variant_get_safe(reply, "(ii)", &reply_default, &reply_current)) {
  79                 _D("Return type mismatching from GetBrightnessInfo.");
  80                 return;
  81         }
  82
  83         match_default = expect_default == reply_default;
  84         match_current = expect_current == reply_current;
  85
  86         printf("%6d %6d %c | %6d %6d %c\n",
  87                 expect_default, reply_default, match_default ? ' ' : 'X',
  88                 expect_current, reply_current, match_current ? ' ' : 'X');
  89
  90         tc_success &= (match_default && match_current);
  91 }
  92
  93 static void hbm_on(int expect_default, int expect_current)
  94 {
  95         print_command("HBM ON");
  96
  97         call_display_method_sync("AutoBrightnessChanged", g_variant_new("(i)", 120));
  98         check_result(expect_default, expect_current);
  99         sleep(CMD_INTERVAL_SEC);
 100 }
 101
 102 static void hbm_off(int expect_default, int expect_current)
 103 {
 104         print_command("HBM OFF");
 105
 106         call_display_method_sync("AutoBrightnessChanged", g_variant_new("(i)", 0));
 107         check_result(expect_default, expect_current);
 108         sleep(CMD_INTERVAL_SEC);
 109 }
 110
 111 static void lbm_on(int expect_default, int expect_current)
 112 {
 113         print_command("LBM ON");
 114
 115         call_display_method_sync("AutoBrightnessChanged", g_variant_new("(i)", 110));
 116         check_result(expect_default, expect_current);
 117         sleep(CMD_INTERVAL_SEC);
 118 }
 119
 120 static void lbm_off(int expect_default, int expect_current)
 121 {
 122         print_command("LBM OFF");
 123
 124         call_display_method_sync("AutoBrightnessChanged", g_variant_new("(i)", 0));
 125         check_result(expect_default, expect_current);
 126         sleep(CMD_INTERVAL_SEC);
 127 }
 128
 129 static void hold(int hold, int expect_default, int expect_current)
 130 {
 131         char command[32];
 132
 133         snprintf(command, sizeof(command), "HOLD %d", hold);
 134         print_command(command);
 135
 136         call_display_method_sync("HoldBrightness", g_variant_new("(i)", hold));
 137         check_result(expect_default, expect_current);
 138         sleep(CMD_INTERVAL_SEC);
 139 }
 140
 141 static void release(int expect_default, int expect_current)
 142 {
 143         print_command("RELEASE");
 144
 145         call_display_method_sync("ReleaseBrightness", NULL);
 146         check_result(expect_default, expect_current);
 147         sleep(CMD_INTERVAL_SEC);
 148 }
 149
 150 static void lowdim_on(int expect_default, int expect_current)
 151 {
 152         print_command("LOWDIM ON");
 153
 154         battery_scenario("bat3", 1);
 155
 156         check_result(expect_default, expect_current);
 157         sleep(CMD_LONG_INTERVAL_SEC);
 158 }
 159
 160 static void lowdim_off(int expect_default, int expect_current)
 161 {
 162         print_command("LOWDIM OFF");
 163
 164         battery_scenario("bat3", 0);
 165
 166         check_result(expect_default, expect_current);
 167         sleep(CMD_LONG_INTERVAL_SEC);
 168 }
 169
 170 static void set(int brightness, int expect_default, int expect_current)
 171 {
 172         char command[32];
 173
 174         snprintf(command, sizeof(command), "SET %d", brightness);
 175         print_command(command);
 176
 177         call_display_method_sync("SetBrightness", g_variant_new("(ii)", 0, brightness));
 178         sleep(CMD_INTERVAL_SEC);
 179         check_result(expect_default, expect_current);
 180 }
 181
 182 static void abnormal_health_on(int expect_default, int expect_current)
 183 {
 184         print_command("ABNORMAL ON");
 185
 186         battery_scenario("heat1", 1);
 187
 188         check_result(expect_default, expect_current);
 189         sleep(CMD_LONG_INTERVAL_SEC);
 190 }
 191
 192 static void abnormal_health_off(int expect_default, int expect_current)
 193 {
 194         print_command("ABNORMAL OFF");
 195
 196         battery_scenario("heat1", 0);
 197
 198         check_result(expect_default, expect_current);
 199         sleep(CMD_LONG_INTERVAL_SEC);
 200 }
 201
 202 static void initialize_test_env(int brightness, const char *fname)
 203 {
 204         printf("[%s]\n", fname);
 205
 206         tc_success = true;
 207
 208         call_display_method_sync("ChangeState", g_variant_new("(s)", "lcdoff"));
 209         sleep(CMD_INTERVAL_SEC);
 210         call_display_method_sync("ChangeState", g_variant_new("(s)", "lcdon"));
 211         sleep(CMD_LONG_INTERVAL_SEC);
 212         printf(" Init brightness: %3d\n", brightness);
 213         call_display_method_sync("SetBrightness", g_variant_new("(ii)", 0, brightness));
 214         sleep(CMD_INTERVAL_SEC);
 215         call_display_method_sync("lockstate", g_variant_new("(sssi)", "lcdon", "staycurstate", "NULL", 0));
 216         sleep(CMD_INTERVAL_SEC);
 217
 218         printf("             |    default      |    current\n");
 219         printf("     Command | expect result   | expect result\n");
 220         sleep(CMD_INTERVAL_SEC);
 221 }
 222 #define initialize(brightness)  initialize_test_env(brightness, __func__)
 223
 224 #define DEFINE_TC(tcname) static void tc_##tcname(void)
 225 DEFINE_TC(hbm)
 226 {
 227         initialize(50);
 228
 229         hbm_on(50, 100);
 230         hbm_off(50, 50);
 231 }
 232
 233 DEFINE_TC(lbm)
 234 {
 235         initialize(100);
 236
 237         /* BrtTable=1,20,40,50,60,70,80,90,95,100
 238          * Level=4
 239          * It lowers brightness 4 level down */
 240         lbm_on(100, 70);
 241         set(1, 1, 1);
 242         set(20, 20, 1);
 243         set(40, 40, 1);
 244         set(50, 50, 1);
 245         set(60, 60, 1);
 246         set(70, 70, 20);
 247         set(80, 80, 40);
 248         set(90, 90, 50);
 249         set(95, 95, 60);
 250         set(100, 100, 70);
 251         lbm_off(100, 100);
 252 }
 253
 254 DEFINE_TC(hold)
 255 {
 256         initialize(50);
 257
 258         hold(100, 50, 100);
 259         release(50, 50);
 260 }
 261
 262 DEFINE_TC(set)
 263 {
 264         initialize(100);
 265
 266         set(40, 40, 40);
 267 }
 268
 269 DEFINE_TC(lowdim)
 270 {
 271         initialize(100);
 272
 273         lowdim_on(100, 0);
 274         lowdim_off(100, 100);
 275 }
 276
 277 DEFINE_TC(abnormal_health)
 278 {
 279         initialize(100);
 280
 281         abnormal_health_on(100, 0);
 282         abnormal_health_off(100, 100);
 283 }
 284
 285 DEFINE_TC(custom1)
 286 {
 287         initialize(50);
 288
 289         lowdim_on(50, 0);
 290         hold(100, 50, 100);
 291         lbm_on(50, 100);
 292         lbm_off(50, 100);
 293         release(50, 0);
 294         lowdim_off(50, 50);
 295 }
 296
 297 #define TESTCASE(tc_function)   {.tcname = #tc_function, .tc = tc_##tc_function }
 298 struct tc_list {
 299         const char *tcname;
 300         void (*tc)(void);
 301 } tc[] = {
 302         /* default testcase */
 303         TESTCASE(hbm),
 304         TESTCASE(lbm),
 305         TESTCASE(hold),
 306         TESTCASE(set),
 307         TESTCASE(lowdim),
 308         TESTCASE(abnormal_health),
 309
 310         /* custom testcase */
 311         TESTCASE(custom1),
 312 };
 313
 314 #define array_len(arr)  (sizeof(arr) / sizeof((arr)[0]))
 315 static void do_test(const char *tcname)
 316 {
 317         int i;
 318         int timeout;
 319         int ret_val = -1;
 320
 321         ret_val = vconf_get_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, &timeout);
 322         if (ret_val == 0) {
 323                 if (vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 300) < 0)
 324                         printf("Failed to set LCDNORMAL timeout, %d.\n", vconf_get_ext_errno());
 325         }
 326
 327         stop_udev();
 328
 329         if (tcname) {
 330                 for (i = 0; i < array_len(tc); ++i) {
 331                         if (strcmp(tcname, tc[i].tcname))
 332                                 continue;
 333                         tc[i].tc();
 334                         if (tc_success)
 335                                 ++success;
 336                         else
 337                                 ++fail;
 338                         printf("--------------------------------------------------\n");
 339                 }
 340         } else {
 341                 for (i = 0; i < array_len(tc); ++i) {
 342                         tc[i].tc();
 343                         if (tc_success)
 344                                 ++success;
 345                         else
 346                                 ++fail;
 347                         printf("--------------------------------------------------\n");
 348                 }
 349         }
 350         printf("Success: %d, Fail: %d\n", success, fail);
 351
 352         start_udev();
 353         if (ret_val == 0) {
 354                 if (vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, timeout) < 0)
 355                         printf("Failed to restore LCDNORMAL timeout, %d.\n", vconf_get_ext_errno());
 356         }
 357 }
 358
 359 static void brightness_init(void *data)
 360 {
 361         do_test(NULL);
 362 }
 363
 364 static int brightness_unit(int argc, char **argv)
 365 {
 366         if (argc < 4)
 367                 do_test(NULL);
 368         else
 369                 do_test(argv[3]);
 370
 371         return 0;
 372 }
 373
 374 static void brightness_exit(void *data)
 375 {
 376         _I("End brightness test.");
 377 }
 378
 379 static const struct test_ops brightness_test_ops = {
 380         .priority = TEST_PRIORITY_NORMAL,
 381         .name     = "brightness",
 382         .init     = brightness_init,
 383         .exit    = brightness_exit,
 384         .unit    = brightness_unit,
 385 };
 386
 387 TEST_OPS_REGISTER(&brightness_test_ops)