unittest/gtest_hal_display.cpp

   1
   2 #include <iostream>
   3 #include <gtest/gtest.h>
   4 #include "hw/common.h"
   5 #include "hw/display.h"
   6
   7 using namespace std;
   8
   9 /*
  10  * main class
  11  */
  12
  13 #define LOWBATTERY "LowBattery"
  14
  15 struct display_device *display_dev;
  16
  17 class DISPLAYHalTest : public testing::Test
  18 {
  19         public:
  20                 virtual void SetUp()
  21                 {
  22                         struct hw_info *info;
  23                         int ret;
  24                         ret = hw_get_info(DISPLAY_HARDWARE_DEVICE_ID,
  25                                         (const struct hw_info **)&info);
  26
  27                         if (ret < 0) {
  28                                 cout << "Fail to load cpu hal(" << ret << ")" << endl;
  29                                 assert(true);
  30                                 return;
  31                         }
  32                         if (!info->open) {
  33                                 cout << "Failed to open cpu device; open(NULL)" << endl;
  34                                 assert(true);
  35                                 return;
  36                         }
  37
  38                         ret = info->open(info, NULL, (struct hw_common**)&display_dev);
  39                         if (ret < 0 || !display_dev) {
  40                                 cout << "Failed to get cpu device structure (" << ret << ")" << endl;
  41                                 assert(true);
  42                                 return;
  43                         }
  44
  45                         return;
  46                 }
  47
  48                 virtual void TearDown()
  49                 {
  50                         struct hw_info *info;
  51
  52                         info = display_dev->common.info;
  53                         if (!info)
  54                                 free(display_dev);
  55                         else
  56                                 info->close((struct hw_common *)display_dev);
  57                         display_dev = NULL;
  58
  59                         return;
  60                 }
  61 };
  62
  63 /*
  64  * testcase
  65  */
  66 TEST_F(DISPLAYHalTest, InitP)
  67 {
  68         EXPECT_NE(display_dev, nullptr);
  69 }
  70
  71 TEST_F(DISPLAYHalTest, DeinitP)
  72 {
  73         struct display_device *tmp;
  74         struct hw_info *info;
  75         int ret;
  76
  77         hw_get_info(DISPLAY_HARDWARE_DEVICE_ID,
  78                         (const struct hw_info **)&info);
  79
  80         EXPECT_NE(info, nullptr);
  81         if (!info->open || !info->close)
  82                 return;
  83         info->open(info, NULL, (struct hw_common**)&tmp);
  84
  85         ret = info->close((struct hw_common *)tmp);
  86         EXPECT_EQ(ret, 0);
  87 }
  88
  89 TEST_F(DISPLAYHalTest, GetMaxBrightnessP)
  90 {
  91         int ret;
  92         int max;
  93
  94         EXPECT_NE(display_dev, nullptr);
  95         if (!display_dev->get_max_brightness)
  96                 return;
  97         ret = display_dev->get_max_brightness(&max);
  98         EXPECT_EQ(ret, 0);
  99 }
 100
 101 TEST_F(DISPLAYHalTest, GetBrightnessP)
 102 {
 103         int ret;
 104         int brt;
 105
 106         EXPECT_NE(display_dev, nullptr);
 107         if (!display_dev->get_brightness)
 108                 return;
 109         ret = display_dev->get_brightness(&brt);
 110         EXPECT_EQ(ret, 0);
 111 }
 112
 113 TEST_F(DISPLAYHalTest, SetBrightnessP)
 114 {
 115         int ret;
 116         int max;
 117
 118         EXPECT_NE(display_dev, nullptr);
 119         if (!display_dev->set_brightness)
 120                 return;
 121         ret = display_dev->get_max_brightness(&max);
 122         ret = display_dev->set_brightness(max);
 123         EXPECT_EQ(ret, 0);
 124 }
 125
 126 TEST_F(DISPLAYHalTest, GetAutoBrightnessP)
 127 {
 128         int ret;
 129         int brt;
 130         float lmax = 0, lmin = 0, light = 0;
 131
 132         EXPECT_NE(display_dev, nullptr);
 133         if (!display_dev->get_auto_brightness)
 134                 return;
 135         ret = display_dev->get_auto_brightness(lmax, lmin, light, &brt);
 136         EXPECT_GE(ret, 0);
 137 }
 138
 139 TEST_F(DISPLAYHalTest, GetStateP)
 140 {
 141         int ret;
 142         enum display_state state;
 143
 144         EXPECT_NE(display_dev, nullptr);
 145         if (!display_dev->get_state)
 146                 return;
 147         ret = display_dev->get_state(&state);
 148         EXPECT_GE(ret, 0);
 149 }
 150
 151 TEST_F(DISPLAYHalTest, SetStateP)
 152 {
 153         int ret;
 154
 155         EXPECT_NE(display_dev, nullptr);
 156         if (!display_dev->set_state)
 157                 return;
 158         ret = display_dev->set_state(DISPLAY_ON);
 159         EXPECT_GE(ret, 0);
 160 }
 161
 162 TEST_F(DISPLAYHalTest, GetMaxFrameRateP)
 163 {
 164         int ret;
 165         int max;
 166
 167         EXPECT_NE(display_dev, nullptr);
 168         if (!display_dev->get_max_frame_rate)
 169                 return;
 170         ret = display_dev->get_max_frame_rate(&max);
 171         EXPECT_GE(ret, 0);
 172 }
 173
 174 TEST_F(DISPLAYHalTest, GetMinFrameRateP)
 175 {
 176         int ret;
 177         int min;
 178
 179         EXPECT_NE(display_dev, nullptr);
 180         if (!display_dev->get_min_frame_rate)
 181                 return;
 182         ret = display_dev->get_min_frame_rate(&min);
 183         EXPECT_GE(ret, 0);
 184 }
 185
 186 TEST_F(DISPLAYHalTest, SetFrameRateP)
 187 {
 188         int ret;
 189         int max;
 190
 191         EXPECT_NE(display_dev, nullptr);
 192         if (!display_dev->set_frame_rate)
 193                 return;
 194         ret = display_dev->get_max_frame_rate(&max);
 195         ret = display_dev->set_frame_rate(max);
 196         EXPECT_GE(ret, 0);
 197 }
 198
 199 int main(int argc, char **argv)
 200 {
 201         testing::InitGoogleTest(&argc, argv);
 202
 203         return RUN_ALL_TESTS();
 204 }