haltest/display.cpp

   1 #include <system_info.h>
   2
   3 #include "haltest.h"
   4 #include "hal-display.h"
   5
   6 using namespace std;
   7
   8 /* Define Classes */
   9 class DISPLAY : public testing::Test
  10 {
  11         protected:
  12                 void SetUp() override
  13                 {
  14                         int ret;
  15
  16                         ret = system_info_get_platform_bool(FEATURE_DISPLAY, &display_supported);
  17                         EXPECT_EQ(SYSTEM_INFO_ERROR_NONE, ret) << "system_info_get_platform_bool failed";
  18                 }
  19
  20                 void TearDown() override
  21                 {
  22
  23                 }
  24
  25                 bool display_supported;
  26 };
  27
  28
  29 /*
  30  * Testcase for Display
  31  */
  32 TEST_F(DISPLAY, GetBackendP)
  33 {
  34         int ret;
  35
  36         if (!display_supported) {
  37                 SKIP_MESSAGE("Display not supported");
  38                 return;
  39         }
  40
  41         ret = hal_device_display_get_backend();
  42         EXPECT_EQ(ret, 0) << "Fail to get display device (" << ret << ")";
  43 }
  44
  45 TEST_F(DISPLAY, GetMaxBrightnessP)
  46 {
  47         int ret;
  48         int max;
  49
  50         if (!display_supported) {
  51                 SKIP_MESSAGE("Display not supported");
  52                 return;
  53         }
  54
  55         ret = hal_device_display_get_max_brightness(&max);
  56         if (ret == -ENODEV)
  57                 return;
  58
  59         EXPECT_EQ(ret, 0) << "Fail to get max brightness (" << ret << ")";
  60 }
  61
  62 TEST_F(DISPLAY, GetBrightnessP)
  63 {
  64         int ret;
  65         int brt;
  66
  67         if (!display_supported) {
  68                 SKIP_MESSAGE("Display not supported");
  69                 return;
  70         }
  71
  72         ret = hal_device_display_get_brightness(&brt);
  73         if (ret == -ENODEV)
  74                 return;
  75
  76         EXPECT_EQ(ret, 0) << "Fail to get brightness (" << ret << ")";
  77 }
  78
  79 TEST_F(DISPLAY, SetBrightnessP)
  80 {
  81         int ret;
  82         int max = 100;
  83
  84         if (!display_supported) {
  85                 SKIP_MESSAGE("Display not supported");
  86                 return;
  87         }
  88
  89         ret = hal_device_display_set_brightness(max);
  90         if (ret == -ENODEV)
  91                 return;
  92
  93         EXPECT_EQ(ret, 0) << "Fail to set_brightness (" << ret << ")";
  94 }
  95
  96 TEST_F(DISPLAY, SetMultiBrightnessP)
  97 {
  98         int ret;
  99         int brt = 50, step = 5, delay = 10000;
 100
 101         if (!display_supported) {
 102                 SKIP_MESSAGE("Display not supported");
 103                 return;
 104         }
 105
 106         ret = hal_device_display_set_multi_brightness(brt, step, delay);
 107         if (ret == -ENODEV)
 108                 return;
 109
 110         EXPECT_EQ(ret, 0) << "Fail to set multi brightness (" << ret << ")";
 111 }
 112
 113 TEST_F(DISPLAY, GetAutoBrightnessP)
 114 {
 115         int ret;
 116         int brt;
 117         float lmax = 0, lmin = 0, light = 0;
 118
 119         if (!display_supported) {
 120                 SKIP_MESSAGE("Display not supported");
 121                 return;
 122         }
 123
 124         ret = hal_device_display_get_auto_brightness(lmax, lmin, light, &brt);
 125         if (ret == -ENODEV)
 126                 return;
 127
 128         EXPECT_EQ(ret, 0) << "Fail to get auto brightness (" << ret << ")";
 129 }
 130
 131 TEST_F(DISPLAY, GetStateP)
 132 {
 133         int ret;
 134         enum display_state state;
 135
 136         if (!display_supported) {
 137                 SKIP_MESSAGE("Display not supported");
 138                 return;
 139         }
 140
 141         ret = hal_device_display_get_state(&state);
 142         if (ret == -ENODEV)
 143                 return;
 144
 145         EXPECT_EQ(ret, 0) << "Fail to get state (" << ret << ")";
 146 }
 147
 148 TEST_F(DISPLAY, SetStateP)
 149 {
 150         int ret;
 151
 152         if (!display_supported) {
 153                 SKIP_MESSAGE("Display not supported");
 154                 return;
 155         }
 156
 157         ret = hal_device_display_set_state(DISPLAY_ON);
 158         if (ret == -ENODEV)
 159                 return;
 160
 161         EXPECT_EQ(ret, 0) << "Fail to set state (" << ret << ")";
 162 }
 163
 164 TEST_F(DISPLAY, GetImageEffectP)
 165 {
 166         enum display_image_effect effect;
 167         int ret;
 168
 169         if (!display_supported) {
 170                 SKIP_MESSAGE("Display not supported");
 171                 return;
 172         }
 173
 174         ret = hal_device_display_get_image_effect(&effect);
 175         if (ret == -ENODEV)
 176                 return;
 177
 178         EXPECT_EQ(ret, 0) << "Fail to get image effect (" << ret << ")";
 179 }
 180
 181 TEST_F(DISPLAY, SetImageEffectP)
 182 {
 183         int ret;
 184
 185         if (!display_supported) {
 186                 SKIP_MESSAGE("Display not supported");
 187                 return;
 188         }
 189
 190         ret = hal_device_display_set_image_effect(DISPLAY_IMAGE_EFFECT_GREY);
 191         if (ret == -ENODEV)
 192                 return;
 193
 194         EXPECT_EQ(ret, 0) << "Fail to set image effect (" << ret << ")";
 195 }
 196
 197 TEST_F(DISPLAY, GetPanelModeP)
 198 {
 199         enum display_panel_mode mode;
 200         int ret;
 201
 202         if (!display_supported) {
 203                 SKIP_MESSAGE("Display not supported");
 204                 return;
 205         }
 206
 207         ret = hal_device_display_get_panel_mode(&mode);
 208         if (ret == -ENODEV)
 209                 return;
 210
 211         EXPECT_EQ(ret, 0) << "Fail to get panel mode (" << ret << ")";
 212 }
 213
 214 TEST_F(DISPLAY, SetPanelModeP)
 215 {
 216         int ret;
 217
 218         if (!display_supported) {
 219                 SKIP_MESSAGE("Display not supported");
 220                 return;
 221         }
 222
 223         ret = hal_device_display_set_panel_mode(DISPLAY_PANEL_MODE_LOWPOWER);
 224         if (ret == -ENODEV)
 225                 return;
 226
 227         EXPECT_EQ(ret, 0) << "Fail to set panel mode (" << ret << ")";
 228 }
 229
 230 TEST_F(DISPLAY, GetAodModeP)
 231 {
 232         enum display_aod_mode mode;
 233         int ret;
 234
 235         if (!display_supported) {
 236                 SKIP_MESSAGE("Display not supported");
 237                 return;
 238         }
 239
 240         ret = hal_device_display_get_aod_mode(&mode);
 241         if (ret == -ENODEV)
 242                 return;
 243
 244         EXPECT_EQ(ret, 0) << "Fail to get aod mode (" << ret << ")";
 245 }
 246
 247 TEST_F(DISPLAY, GetAodBrightnessP)
 248 {
 249         int max, normal, min, charging;
 250         int ret;
 251
 252         if (!display_supported) {
 253                 SKIP_MESSAGE("Display not supported");
 254                 return;
 255         }
 256
 257         ret = hal_device_display_get_aod_brightness(&max, &normal, &min, &charging);
 258         if (ret == -ENODEV)
 259                 return;
 260
 261         EXPECT_EQ(ret, 0) << "Fail to get aod brightness (" << ret << ")";
 262 }
 263
 264
 265 TEST_F(DISPLAY, GetMaxFrameRateP)
 266 {
 267         int ret;
 268         int max;
 269
 270         if (!display_supported) {
 271                 SKIP_MESSAGE("Display not supported");
 272                 return;
 273         }
 274
 275         ret = hal_device_display_get_max_frame_rate(&max);
 276         if (ret == -ENODEV)
 277                 return;
 278
 279         EXPECT_GE(ret, 0) << "Fail to get max frame_rate (" << ret << ")";
 280 }
 281
 282 TEST_F(DISPLAY, GetMinFrameRateP)
 283 {
 284         int ret;
 285         int min;
 286
 287         if (!display_supported) {
 288                 SKIP_MESSAGE("Display not supported");
 289                 return;
 290         }
 291
 292         ret = hal_device_display_get_min_frame_rate(&min);
 293         if (ret == -ENODEV)
 294                 return;
 295
 296         EXPECT_GE(ret, 0) << "Fail to get min frame rate (" << ret << ")";
 297 }
 298
 299 TEST_F(DISPLAY, GetFrameRateP)
 300 {
 301         int ret, rate;
 302
 303         if (!display_supported) {
 304                 SKIP_MESSAGE("Display not supported");
 305                 return;
 306         }
 307
 308         ret = hal_device_display_get_frame_rate(&rate);
 309         if (ret == -ENODEV)
 310                 return;
 311
 312         EXPECT_GE(ret, 0) << "Fail to get frame rate (" << ret << ")";
 313 }
 314
 315 TEST_F(DISPLAY, SetFrameRateP)
 316 {
 317         int ret, fmax;
 318
 319         if (!display_supported) {
 320                 SKIP_MESSAGE("Display not supported");
 321                 return;
 322         }
 323
 324         ret = hal_device_display_get_max_frame_rate(&fmax);
 325         if (ret == -ENODEV)
 326                 return;
 327
 328         EXPECT_GE(ret, 0) << "Fail to get max frame rate (" << ret << ")";
 329
 330         ret = hal_device_display_set_frame_rate(fmax);
 331         if (ret == -ENODEV)
 332                 return;
 333
 334         EXPECT_GE(ret, 0) << "Fail to set frame rate (" << ret << ")";
 335 }