From: Chanwoo Choi Date: Tue, 13 Sep 2022 23:17:18 +0000 (+0900) Subject: tests: unittest: Add pass-rescon-unittests X-Git-Tag: accepted/tizen/unified/20230306.172219~2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8fed49e0a6b671b8bb8e44484ff5ca8930af2277;p=platform%2Fcore%2Fsystem%2Fpass.git tests: unittest: Add pass-rescon-unittests [Test result of pass-rescon-unittests] [ 2s] 1: Test command: /home/abuild/rpmbuild/BUILD/pass-2.0.0/tests/unittest/pass-rescon/pass-rescon-unittests [ 2s] 1: Test timeout computed to be: 10000000 [ 2s] 1: [==========] Running 22 tests from 2 test suites. [ 2s] 1: [----------] Global test environment set-up. [ 2s] 1: [----------] 1 test from PassResconInitExitTest [ 2s] 1: [ RUN ] PassResconInitExitTest.pass_rescon_prepare_and_init_and_exit [ 2s] 1: [ OK ] PassResconInitExitTest.pass_rescon_prepare_and_init_and_exit (0 ms) [ 2s] 1: [----------] 1 test from PassResconInitExitTest (0 ms total) [ 2s] 1: [ 2s] 1: [----------] 21 tests from PassResconTest [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_init_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_init_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_curr_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_curr_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_prev_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_prev_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_min_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_min_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_max_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_max_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_init_scenario_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_init_scenario_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_get_init_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_get_init_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_get_curr_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_get_curr_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_get_prev_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_get_prev_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_get_min_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_get_min_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_get_max_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_get_max_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_sync [ 2s] 1: [ OK ] PassResconTest.pass_rescon_sync (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_level_sync [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_level_sync (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_level_and_pass_rescon_sync [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_level_and_pass_rescon_sync (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_scenario_level_sync [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_scenario_level_sync (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_scenario_set_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_scenario_set_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_set_scenario_level_and_pass_rescon_sync [ 2s] 1: [ OK ] PassResconTest.pass_rescon_set_scenario_level_and_pass_rescon_sync (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_unset_scenario_level_sync [ 2s] 1: [ OK ] PassResconTest.pass_rescon_unset_scenario_level_sync (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_unset_scenario_level [ 2s] 1: [ OK ] PassResconTest.pass_rescon_unset_scenario_level (0 ms) [ 2s] 1: [ RUN ] PassResconTest.pass_rescon_unset_scenario_level_and_pass_rescon_sync [ 2s] 1: [ OK ] PassResconTest.pass_rescon_unset_scenario_level_and_pass_rescon_sync (0 ms) [ 2s] 1: [----------] 21 tests from PassResconTest (5 ms total) [ 2s] 1: [ 2s] 1: [----------] Global test environment tear-down [ 2s] 1: [==========] 22 tests from 2 test suites ran. (6 ms total) [ 2s] 1: [ PASSED ] 22 tests. [ 2s] 1/1 Test #1: pass-rescon-unittests ............ Passed 0.01 sec Change-Id: Ifcf5dc54805e3e40346d6486cae411eb5b8e99c6 Signed-off-by: Chanwoo Choi --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 866d161..1b8b64a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -149,6 +149,7 @@ INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/systemd/ DESTINATION lib/systemd/s ADD_SUBDIRECTORY(tests/integration-test) ADD_SUBDIRECTORY(tests/haltest) ADD_SUBDIRECTORY(tests/unittest/pass-hal-and-parser) +ADD_SUBDIRECTORY(tests/unittest/pass-rescon) ADD_SUBDIRECTORY(lib) diff --git a/packaging/pass.spec b/packaging/pass.spec index 328ecf0..7e4fc3e 100644 --- a/packaging/pass.spec +++ b/packaging/pass.spec @@ -90,6 +90,7 @@ make %{?jobs:-j%jobs} %check (cd tests/unittest/pass-hal-and-parser && LD_LIBRARY_PATH=../../ ctest -V) +(cd tests/unittest/pass-rescon && LD_LIBRARY_PATH=../../ ctest -V) %install rm -rf %{buildroot} diff --git a/tests/unittest/pass-rescon/CMakeLists.txt b/tests/unittest/pass-rescon/CMakeLists.txt new file mode 100644 index 0000000..8d8a82d --- /dev/null +++ b/tests/unittest/pass-rescon/CMakeLists.txt @@ -0,0 +1,43 @@ +ENABLE_TESTING() +SET(PASS_UNITTEST "pass-rescon-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/util/common.c + ${CMAKE_SOURCE_DIR}/src/pass/pass-rescon.c +) + +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/ PASS_UNITTEST_SRCS) +ADD_EXECUTABLE(${PASS_UNITTEST} ${PASS_UNITTEST_SRCS} ${PASS_SRCS}) + +TARGET_INCLUDE_DIRECTORIES(${PASS_UNITTEST} PUBLIC + "${CMAKE_CURRENT_SOURCE_DIR}/../../include" + "${CMAKE_SOURCE_DIR}" + "${CMAKE_SOURCE_DIR}/src" + "${CMAKE_SOURCE_DIR}/src/pass" + "${CMAKE_SOURCE_DIR}/include" +) + +INCLUDE(FindPkgConfig) +pkg_check_modules(pass_unittest_pkgs REQUIRED + glib-2.0 + gio-2.0 + gmock + dlog + json-c +) + +FOREACH(flag ${pass_unittest_pkgs_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +TARGET_LINK_LIBRARIES(${PASS_UNITTEST} ${pass_unittest_pkgs_LDFLAGS}) +SET_TARGET_PROPERTIES(${PASS_UNITTEST} PROPERTIES COMPILE_FLAGS "-fPIE -fvisibility=default") +SET_TARGET_PROPERTIES(${PASS_UNITTEST} PROPERTIES LINK_FLAGS "-pie") + +ADD_TEST( + NAME ${PASS_UNITTEST} + COMMAND ${PASS_UNITTEST} +) diff --git a/tests/unittest/pass-rescon/pass-rescon-unittests.cc b/tests/unittest/pass-rescon/pass-rescon-unittests.cc new file mode 100644 index 0000000..315d4ef --- /dev/null +++ b/tests/unittest/pass-rescon/pass-rescon-unittests.cc @@ -0,0 +1,636 @@ +/* + * Copyright (C) 2022 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include +#include +#include + +extern "C" { +#include + +#include "pass.h" +#include "pass-hal.h" +#include "pass-rescon.h" +} + +#include "pass-hal-mock.hpp" + +#define INIT_LEVEL_VALUE 100 + +using namespace std; +using ::testing::Return; +using ::testing::_; + +struct pass_resource *g_resource; + +static void init_pass_hal(void) +{ + if (gPassHalMock) + return; + + gPassHalMock = new PassHalMock(); + + g_resource = (struct pass_resource *)calloc(1, sizeof(struct pass_resource)); + g_resource->config_data.res_type = PASS_RESOURCE_CPU_ID; + + EXPECT_CALL(*gPassHalMock, pass_hal_save_initdata(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_restore_initdata(_)).WillRepeatedly(Return(0)); + + /* Get and the current governor. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_curr_governor(_, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_curr_governor(_, _)).WillRepeatedly(Return(0)); + + /* Get the current frequency. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_curr_freq(_)).WillRepeatedly(Return(0)); + + /* Get and set the minimum frequency. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_min_freq(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_min_freq(_, _)).WillRepeatedly(Return(0)); + + /* Get and set the maximum frequency. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_max_freq(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_max_freq(_, _)).WillRepeatedly(Return(0)); + + /* Get the minimum/maximum frequency which can be set to resource. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_available_min_freq(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_get_available_max_freq(_)).WillRepeatedly(Return(0)); + + /* Get and set the up_threshold to support boosting. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_up_threshold(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_up_threshold(_, _)).WillRepeatedly(Return(0)); + + /* Get the temperature and policy of thermal unit on specific h/w. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_temp(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_get_tmu_policy(_, _)).WillRepeatedly(Return(0)); + + /* Get and set the state of cooling device on specific h/w. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_cooling_device_state(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_cooling_device_state(_, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_get_cooling_device_max_state(_)).WillRepeatedly(Return(0)); + + /* Get and set the battery charging state. */ + EXPECT_CALL(*gPassHalMock, pass_hal_set_battery_charging_status(_, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_get_battery_charging_status(_)).WillRepeatedly(Return(0)); + + /* Get and set the battery charging current. */ + EXPECT_CALL(*gPassHalMock, pass_hal_set_battery_charging_current(_, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_get_battery_charging_current(_)).WillRepeatedly(Return(0)); + + /* Get and set online state of cpu. */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_online_state(_, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_online_state(_, _, _)).WillRepeatedly(Return(0)); + /* Get and set the minimum number of online CPUs */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_online_min_num(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_online_min_num(_, _)).WillRepeatedly(Return(0)); + /* Get and set the maximum number of online CPUs */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_online_max_num(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_online_max_num(_, _)).WillRepeatedly(Return(0)); + + /* Get and set the /sys/kernel/debug/fault_around_bytes */ + EXPECT_CALL(*gPassHalMock, pass_hal_get_fault_around_bytes(_)).WillRepeatedly(Return(0)); + EXPECT_CALL(*gPassHalMock, pass_hal_set_fault_around_bytes(_, _)).WillRepeatedly(Return(0)); + + /* + * NOTE: It is not propper method. But PASS must need to keep + * the backwards compatibility, set the PMQoS's data from + * platform to hal. So, It is not recommended to use it. + * + * This function will be removed after finding the proper method. + */ + EXPECT_CALL(*gPassHalMock, pass_hal_set_pmqos_data(_, _)).WillRepeatedly(Return(0)); +} + +static void exit_pass_hal(void) +{ + free(g_resource); + g_resource = NULL; + + if (!gPassHalMock) + return; + + delete gPassHalMock; + gPassHalMock = NULL; +} + class PassResconInitExitTest : public testing::Test { +public: + void SetUp() override { + init_pass_hal(); + } + + void TearDown() override { + exit_pass_hal(); + } +}; + +TEST_F(PassResconInitExitTest, pass_rescon_prepare_and_init_and_exit) { + int ret = pass_rescon_prepare(g_resource); + EXPECT_EQ(ret, 0); + ret = pass_rescon_init(g_resource); + EXPECT_EQ(ret, 0); + ret = pass_rescon_exit(g_resource); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_prepare(NULL); + EXPECT_NE(ret, 0); + ret = pass_rescon_init(NULL); + EXPECT_NE(ret, 0); + ret = pass_rescon_exit(NULL); + EXPECT_NE(ret, 0); +} + +class PassResconTest : public testing::Test { +public: + void SetUp() override { + init_pass_hal(); + + pass_rescon_prepare(g_resource); + pass_rescon_init(g_resource); + } + + void TearDown() override { + pass_rescon_exit(g_resource); + + exit_pass_hal(); + } +}; + +TEST_F(PassResconTest, pass_rescon_set_init_level) { + int ret = pass_rescon_set_init_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_set_init_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_init_level(NULL, 0); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_init_level(g_resource, -1); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_init_level(g_resource, INT_MAX); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_curr_level) { + int ret = pass_rescon_set_curr_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_set_curr_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_curr_level(NULL, 0); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_curr_level(g_resource, -1); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_curr_level(g_resource, INT_MAX); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_prev_level) { + int ret = pass_rescon_set_prev_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_set_prev_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_prev_level(NULL, 0); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_prev_level(g_resource, -1); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_prev_level(g_resource, INT_MAX); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_min_level) { + int ret = pass_rescon_set_min_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_set_min_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_min_level(NULL, 0); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_min_level(g_resource, -1); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_min_level(g_resource, INT_MAX); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_max_level) { + int ret = pass_rescon_set_max_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_set_max_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_max_level(NULL, 0); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_max_level(g_resource, -1); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_max_level(g_resource, INT_MAX); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_init_scenario_level) { + int ret = pass_rescon_set_init_scenario_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_set_init_scenario_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_init_scenario_level(NULL, 0); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_init_scenario_level(g_resource, -1); + EXPECT_NE(ret, 0); + ret = pass_rescon_set_init_scenario_level(g_resource, INT_MAX); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_get_init_level) { + int ret = pass_rescon_set_init_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + int level = 0; + ret = pass_rescon_get_init_level(g_resource, &level); + EXPECT_EQ(ret, INIT_LEVEL_VALUE); + + ret = pass_rescon_get_init_level(NULL, &level); + EXPECT_NE(ret, 0); + ret = pass_rescon_get_init_level(g_resource, NULL); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_get_curr_level) { + int ret = pass_rescon_set_curr_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + int level = 0; + ret = pass_rescon_get_curr_level(g_resource, &level); + EXPECT_EQ(ret, INIT_LEVEL_VALUE); + + ret = pass_rescon_get_curr_level(NULL, &level); + EXPECT_NE(ret, 0); + ret = pass_rescon_get_curr_level(g_resource, NULL); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_get_prev_level) { + int ret = pass_rescon_set_prev_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + int level = 0; + ret = pass_rescon_get_prev_level(g_resource, &level); + EXPECT_EQ(ret, INIT_LEVEL_VALUE); + + ret = pass_rescon_get_prev_level(NULL, &level); + EXPECT_NE(ret, 0); + ret = pass_rescon_get_prev_level(g_resource, NULL); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_get_min_level) { + int ret = pass_rescon_set_min_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + int level = 0; + ret = pass_rescon_get_min_level(g_resource, &level); + EXPECT_EQ(ret, INIT_LEVEL_VALUE); + + ret = pass_rescon_get_min_level(NULL, &level); + EXPECT_NE(ret, 0); + ret = pass_rescon_get_min_level(g_resource, NULL); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_get_max_level) { + int ret = pass_rescon_set_max_level(g_resource, INIT_LEVEL_VALUE); + EXPECT_EQ(ret, 0); + + int level = 0; + ret = pass_rescon_get_max_level(g_resource, &level); + EXPECT_EQ(ret, INIT_LEVEL_VALUE); + + ret = pass_rescon_get_max_level(NULL, &level); + EXPECT_NE(ret, 0); + ret = pass_rescon_get_max_level(g_resource, NULL); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_sync) { + int ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_sync(NULL); + EXPECT_NE(ret, 0); +} + + +static int init_config_data(struct pass_resource *res, + int num_levels, + int num_scenario_levels) { + int ret; + + if (!res) + return -EINVAL; + + res->config_data.levels = (struct pass_level *)calloc(num_levels, + sizeof(struct pass_level)); + if (!res->config_data.levels) + return -ENOMEM; + + res->config_data.scenario_levels = (struct pass_level *)calloc(num_scenario_levels, + sizeof(struct pass_level)); + if (!res->config_data.scenario_levels) { + ret = -ENOMEM; + goto err_levels; + } + + ret = pass_rescon_set_min_level(g_resource, 0); + if (ret < 0) + goto err_scenario_levels; + + ret = pass_rescon_set_max_level(g_resource, num_levels - 1); + if (ret < 0) + goto err_scenario_levels; + + return 0; + +err_scenario_levels: + free(res->config_data.scenario_levels); +err_levels: + free(res->config_data.levels); + + return ret; +} + +TEST_F(PassResconTest, pass_rescon_set_level_sync) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_level_sync(g_resource, 0); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_level_sync(g_resource, 4); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_level_sync(g_resource, 6); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_level_sync(g_resource, -1); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_level_sync(NULL, 0); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_level) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, 0); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, 4); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, 6); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, -1); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_level(NULL, 0); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_level_and_pass_rescon_sync) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, 4); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, 6); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, -1); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_level(NULL, 0); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_scenario_level_sync) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level_sync(g_resource, 0); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level_sync(g_resource, 4); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level_sync(g_resource, 6); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level_sync(g_resource, -1); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_scenario_level_sync(NULL, 0); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_scenario_set_level) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 0); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 4); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 6); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, -1); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_scenario_level(NULL, 0); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_set_scenario_level_and_pass_rescon_sync) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 4); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 6); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_level(g_resource, -1); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_scenario_level(NULL, 0); + EXPECT_NE(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_unset_scenario_level_sync) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level_sync(g_resource, 0); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level_sync(g_resource, 4); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_unset_scenario_level_sync(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_unset_scenario_level_sync(g_resource, 4); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level_sync(g_resource, 6); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level_sync(g_resource, -1); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_unset_scenario_level_sync(g_resource, 6); + EXPECT_EQ(ret, 0); + ret = pass_rescon_unset_scenario_level_sync(g_resource, -1); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_set_scenario_level_sync(NULL, 0); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_unset_scenario_level) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 0); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 4); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_unset_scenario_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_unset_scenario_level(g_resource, 4); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 6); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, -1); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_unset_scenario_level(g_resource, 6); + EXPECT_EQ(ret, 0); + ret = pass_rescon_unset_scenario_level(g_resource, -1); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_unset_scenario_level(NULL, 0); + EXPECT_NE(ret, 0); +} + +TEST_F(PassResconTest, pass_rescon_unset_scenario_level_and_pass_rescon_sync) { + int ret = init_config_data(g_resource, 5, 5); + EXPECT_EQ(ret, 0); + + /* Set min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 0); + EXPECT_EQ(ret, 0); + /* Set max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 4); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_unset_scenario_level(g_resource, 0); + EXPECT_EQ(ret, 0); + ret = pass_rescon_unset_scenario_level(g_resource, 4); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + /* Try to set over max level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, 6); + EXPECT_EQ(ret, 0); + /* Try to set under min level between 0 and 4 */ + ret = pass_rescon_set_scenario_level(g_resource, -1); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_unset_scenario_level(g_resource, 6); + EXPECT_EQ(ret, 0); + ret = pass_rescon_unset_scenario_level(g_resource, -1); + EXPECT_EQ(ret, 0); + ret = pass_rescon_sync(g_resource); + EXPECT_EQ(ret, 0); + + ret = pass_rescon_unset_scenario_level(NULL, 0); + EXPECT_NE(ret, 0); +} + +int main(int argc, char *argv[]) +{ + try { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); + } catch (...) { + return EXIT_FAILURE; + } +}