tests: unittest: Add unittest of pass-hal module

The pass-hal module is in charge of communicating with hal-api-power
for writing the value to h/w resource such as CPU/GPU/Battery etc
and for reading the value from h/w resources.

Change-Id: Icc9b5d48b2a30771753afd241e39e67ddf86c62f
Signed-off-by: Chanwoo Choi <cw00.choi@samsung.com>

diff --git a/tests/unittest/CMakeLists.txt b/tests/unittest/CMakeLists.txt
index 25b89aa..9d89951 100644 (file)
--- a/tests/unittest/CMakeLists.txt
+++ b/tests/unittest/CMakeLists.txt
@@ -4,8 +4,12 @@ SET(PASS_UNITTEST "pass-unittests")
 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -Wall -Werror")
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -Wall -Werror")
 
+SET(PASS_SRCS
+       ${CMAKE_SOURCE_DIR}/src/pass/pass-hal.c
+)
+
 AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/ PASS_UNITTEST_SRCS)
-ADD_EXECUTABLE(${PASS_UNITTEST} ${PASS_UNITTEST_SRCS})
+ADD_EXECUTABLE(${PASS_UNITTEST} ${PASS_UNITTEST_SRCS} ${PASS_SRCS})
 
 TARGET_INCLUDE_DIRECTORIES(${PASS_UNITTEST} PUBLIC
        "${CMAKE_CURRENT_SOURCE_DIR}/../../include"

diff --git a/tests/unittest/pass-unittests.cc b/tests/unittest/pass-unittests.cc
index 14748d2..736ebde 100644 (file)
--- a/tests/unittest/pass-unittests.cc
+++ b/tests/unittest/pass-unittests.cc
@@ -21,6 +21,475 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
+extern "C" {
+#include <util/common.h>
+
+#include "pass.h"
+#include "pass-hal.h"
+}
+
+#include "hal-api-power-mock.hpp"
+
+#define                FREQ_100MZ              100000
+#define                CHARGING_CURRNT_1A      1000000
+#define                DEFAULT_MINUS_INT       -1
+#define                DEFAULT_UP_THRESHOLD    90
+
+using namespace std;
+using ::testing::Return;
+using ::testing::_;
+
+class PassHalTest : public testing::Test {
+public:
+       void SetUp() override {
+               gHalApiPowerMock = new HalApiPowerMock();
+       }
+
+       void TearDown() override {
+               if (!gHalApiPowerMock)
+                       return;
+
+               delete gHalApiPowerMock;
+               gHalApiPowerMock = NULL;
+       }
+};
+
+TEST_F(PassHalTest, pass_hal_get_resource) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock,
+               hal_power_get_backend(_)).WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_resource(&res);
+       EXPECT_EQ(ret, 0);
+
+       ret = pass_hal_get_resource(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_put_resource) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock,
+               hal_power_put_backend()).WillRepeatedly(Return(0));
+
+       ret = pass_hal_put_resource(&res);
+       EXPECT_EQ(ret, 0);
+
+       ret = pass_hal_put_resource(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_curr_governor) {
+       struct pass_resource res;
+       char buf[BUFF_MAX];
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_get_curr_governor(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_curr_governor(&res, buf);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_curr_governor(&res, NULL);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_get_curr_governor(NULL, buf);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_curr_governor) {
+       struct pass_resource res;
+       char buf[BUFF_MAX];
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_set_curr_governor(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_curr_governor(&res, buf);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_curr_governor(&res, NULL);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_curr_governor(NULL, buf);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_curr_freq) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_get_curr_freq(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_curr_freq(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_curr_freq(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_min_freq) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_get_min_freq(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_min_freq(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_min_freq(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_min_freq) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_set_min_freq(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_min_freq(&res, FREQ_100MZ);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_min_freq(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_min_freq(NULL, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_max_freq) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_get_max_freq(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_max_freq(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_max_freq(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_max_freq) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_set_max_freq(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_max_freq(&res, FREQ_100MZ);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_max_freq(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_max_freq(NULL, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_available_min_freq) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_get_available_min_freq(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_available_min_freq(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_available_min_freq(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_available_max_freq) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_get_available_max_freq(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_available_max_freq(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_available_max_freq(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_up_threshold) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_get_up_threshold(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_up_threshold(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_up_threshold(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_up_threshold) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_dvfs_set_up_threshold(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_up_threshold(&res, DEFAULT_UP_THRESHOLD);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_up_threshold(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_up_threshold(NULL, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_online_state) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_hotplug_get_online_state(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_online_state(&res, 0);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_online_state(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_get_online_state(NULL, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_online_state) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_hotplug_set_online_state(_, _, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_online_state(&res, 0, 1);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_online_state(&res, 0, 0);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_online_state(&res, 0, 10);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_online_state(&res, DEFAULT_MINUS_INT, 1);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_online_state(&res, 0, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_online_state(NULL, DEFAULT_MINUS_INT, 1);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_online_min_num) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_hotplug_get_online_min_num (_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_online_min_num(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_online_min_num(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_online_min_num) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_hotplug_set_online_min_num (_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_online_min_num(&res, 1);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_online_min_num(NULL, 2);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_online_min_num(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_online_max_num) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_hotplug_get_online_max_num (_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_online_max_num(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_online_max_num(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_online_max_num) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_hotplug_set_online_max_num (_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_online_max_num(&res, 1);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_online_max_num(NULL, 2);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_online_max_num(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_temp) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_thermal_get_temp(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_temp(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_temp(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_tmu_policy) {
+       struct pass_resource res;
+       char buf[BUFF_MAX];
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_thermal_get_policy(_, _,_))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_tmu_policy(&res, buf);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_tmu_policy(&res, NULL);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_get_tmu_policy(NULL, buf);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_cooling_device_state) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_thermal_get_cooling_device_state(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_cooling_device_state(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_cooling_device_state(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_cooling_device_state) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_thermal_set_cooling_device_state(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_cooling_device_state(&res, 1);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_cooling_device_state(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_cooling_device_state(NULL, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_battery_charging_status) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_battery_get_charging_status(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_battery_charging_status(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_battery_charging_status(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_battery_charging_status) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_battery_set_charging_status(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_battery_charging_status(&res, 0);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_battery_charging_status(&res, 1);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_battery_charging_status(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_battery_charging_status(NULL, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_battery_charging_current) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_battery_get_charging_current(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_battery_charging_current(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_battery_charging_current(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_battery_charging_current) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_battery_set_charging_current(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_battery_charging_current(&res, CHARGING_CURRNT_1A);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_battery_charging_current(&res, 0);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_battery_charging_current(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_battery_charging_current(NULL, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_get_fault_around_bytes) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_memory_get_fault_around_bytes(_, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_get_fault_around_bytes(&res);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_get_fault_around_bytes(NULL);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_fault_around_bytes) {
+       struct pass_resource res;
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_memory_set_fault_around_bytes(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_fault_around_bytes(&res, FREQ_100MZ);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_fault_around_bytes(&res, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_fault_around_bytes(NULL, DEFAULT_MINUS_INT);
+       EXPECT_NE(ret, 0);
+}
+
+TEST_F(PassHalTest, pass_hal_set_pmqos_data) {
+       struct pass_resource res;
+       char buf[BUFF_MAX];
+       int ret;
+
+       EXPECT_CALL(*gHalApiPowerMock, hal_power_misc_set_pmqos_data(_, _, _))
+               .WillRepeatedly(Return(0));
+
+       ret = pass_hal_set_pmqos_data(&res, (void *)buf);
+       EXPECT_EQ(ret, 0);
+       ret = pass_hal_set_pmqos_data(NULL, (void *)buf);
+       EXPECT_NE(ret, 0);
+       ret = pass_hal_set_pmqos_data(NULL, NULL);
+       EXPECT_NE(ret, 0);
+}
+
 int main(int argc, char *argv[])
 {
        try {