--- /dev/null
+/*
+ * 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 <iostream>
+#include <unistd.h>
+
+#include <gio/gio.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+extern "C" {
+#include <util/common.h>
+
+#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;
+ }
+}
projects / platform / core / system / pass.git / commitdiff