--- /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 <stdlib.h>
+
+#include <gio/gio.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <vector>
+#include <memory>
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "resource-monitor.h"
+
+#define ARRAY_SIZE(name) (sizeof(name)/sizeof(name[0]))
+
+#define UNKNOWN_ID 9999
+#define UNKNOWN_ATTR_MASK 0xffffffffffffffff
+
+using namespace std;
+
+class ResourceMonitorTest : public testing::Test {
+public:
+ void SetUp() override {}
+ void TearDown() override {}
+};
+
+TEST_F(ResourceMonitorTest, resource_monitor_init_and_exit)
+{
+ int id = resource_monitor_init();
+ EXPECT_TRUE(id > 0);
+
+ int ret = resource_monitor_exit(id);
+ EXPECT_EQ(ret, 0);
+}
+
+TEST_F(ResourceMonitorTest, resource_monitor_get_resource_count_valid)
+{
+ int i;
+ int res_types[] = {
+ RESOURCE_MONITOR_TYPE_CPU,
+ RESOURCE_MONITOR_TYPE_BUS,
+ RESOURCE_MONITOR_TYPE_GPU,
+ RESOURCE_MONITOR_TYPE_MEMORY,
+ RESOURCE_MONITOR_TYPE_BATTERY,
+ RESOURCE_MONITOR_TYPE_DISPLAY,
+ RESOURCE_MONITOR_TYPE_SYSTEM,
+ RESOURCE_MONITOR_TYPE_DISK,
+ };
+
+ int id = resource_monitor_init();
+ ASSERT_TRUE(id > 0);
+
+ for (i = 0; i < (int)ARRAY_SIZE(res_types); i++) {
+ int count;
+ int ret = resource_monitor_get_resource_count(id, res_types[i], &count);
+ EXPECT_EQ(ret, 0);
+ }
+
+ int ret = resource_monitor_exit(id);
+ EXPECT_EQ(ret, 0);
+}
+
+TEST_F(ResourceMonitorTest, resource_monitor_get_resource_count_invalid)
+{
+ int i;
+ int res_types[] = {
+ RESOURCE_MONITOR_TYPE_UNKNOWN,
+ RESOURCE_MONITOR_TYPE_NONSTANDARD,
+ };
+
+ int id = resource_monitor_init();
+ ASSERT_TRUE(id > 0);
+
+ for (i = 0; i < (int)ARRAY_SIZE(res_types); i++) {
+ int count;
+ int ret = resource_monitor_get_resource_count(id, res_types[i], &count);
+ EXPECT_NE(ret, 0);
+ }
+
+ int ret = resource_monitor_exit(id);
+ EXPECT_EQ(ret, 0);
+}
+
+TEST_F(ResourceMonitorTest,
+ resource_monitor_is_resource_attr_supported_invalid)
+{
+ int i, j;
+ int res_type = RESOURCE_TYPE_CPU;
+ u_int64_t res_attr_ids[] = {
+ BIT(50),
+ BIT(51),
+ BIT(52),
+ };
+
+ int id = resource_monitor_init();
+ ASSERT_TRUE(id > 0);
+
+ int count;
+ int ret = resource_monitor_get_resource_count(id, res_type, &count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < count; i++) {
+ int res_id = resource_monitor_create_resource(id, res_type);
+ EXPECT_TRUE(res_id >= 0);
+
+ ret = resource_monitor_set_resource_ctrl(id, res_id,
+ CPU_CTRL_CLUSTER_ID, i);
+ EXPECT_EQ(ret, 0);
+
+ for (j = 0; j < (int)ARRAY_SIZE(res_attr_ids); j++) {
+ bool supported;
+
+ ret = resource_monitor_is_resource_attr_supported(
+ id, res_id,
+ res_attr_ids[j],
+ &supported);
+ EXPECT_NE(ret, 0);
+ EXPECT_EQ(supported, false);
+
+ ret = resource_monitor_is_resource_attr_supported(
+ UNKNOWN_ID, res_id,
+ res_attr_ids[j],
+ &supported);
+ EXPECT_NE(ret, 0);
+ EXPECT_EQ(supported, false);
+
+ ret = resource_monitor_is_resource_attr_supported(
+ id, UNKNOWN_ID,
+ res_attr_ids[j],
+ &supported);
+ EXPECT_NE(ret, 0);
+ EXPECT_EQ(supported, false);
+ }
+
+ ret = resource_monitor_delete_resource(id, res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ ret = resource_monitor_exit(id);
+ EXPECT_EQ(ret, 0);
+}
+
+struct resource_attr_info {
+ u_int64_t attr_id;
+ int attr_type;
+ int array_type;
+};
+
+class PhysicalResourceInfo {
+public:
+ const int type;
+ const char *name;
+ int mon_id;
+ int res_id;
+ int count;
+ const u_int64_t ctrl_id;
+ const int num_attrs;
+ vector<struct resource_attr_info> attrs;
+
+ PhysicalResourceInfo(
+ const int type_,
+ const char *name_,
+ int mon_id_,
+ int res_id_,
+ int count_,
+ const u_int64_t ctrl_id_,
+ const int num_attrs_,
+ vector<struct resource_attr_info> attrs_) :
+ type(type_),
+ name(name_),
+ mon_id(mon_id_),
+ res_id(res_id_),
+ count(count_),
+ ctrl_id(ctrl_id_),
+ num_attrs(num_attrs_),
+ attrs(attrs_) {}
+};
+
+class PhysicalResourceMonitorTest : public ::testing::TestWithParam<PhysicalResourceInfo> {};
+
+INSTANTIATE_TEST_CASE_P (ResourceMonitorTest, PhysicalResourceMonitorTest,
+ ::testing::Values (
+ PhysicalResourceInfo (
+ RESOURCE_TYPE_CPU,
+ "RESOURCE_TYPE_CPU",
+ -1,
+ -1,
+ 0,
+ CPU_CTRL_CLUSTER_ID,
+ 7,
+ vector<struct resource_attr_info> {
+ { .attr_id = RESOURCE_MONITOR_CPU_ATTR_CUR_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_CPU_ATTR_MIN_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_CPU_ATTR_MAX_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_CPU_ATTR_AVAILABLE_MIN_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_CPU_ATTR_AVAILABLE_MAX_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_CPU_ATTR_CUR_GOVERNOR, .attr_type = DATA_TYPE_STRING, },
+ { .attr_id = RESOURCE_MONITOR_CPU_ATTR_NAME, .attr_type = DATA_TYPE_STRING, },
+ }
+ ),
+
+ PhysicalResourceInfo (
+ RESOURCE_TYPE_BUS,
+ "RESOURCE_TYPE_BUS",
+ -1,
+ -1,
+ 0,
+ BUS_CTRL_DEVICE_ID,
+ 7,
+ vector<struct resource_attr_info> {
+ { .attr_id = RESOURCE_MONITOR_BUS_ATTR_CUR_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BUS_ATTR_MIN_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BUS_ATTR_MAX_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BUS_ATTR_AVAILABLE_MIN_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BUS_ATTR_AVAILABLE_MAX_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BUS_ATTR_CUR_GOVERNOR, .attr_type = DATA_TYPE_STRING, },
+ { .attr_id = RESOURCE_MONITOR_BUS_ATTR_NAME, .attr_type = DATA_TYPE_STRING, },
+ }
+ ),
+
+ PhysicalResourceInfo (
+ RESOURCE_TYPE_GPU,
+ "RESOURCE_TYPE_GPU",
+ -1,
+ -1,
+ 0,
+ GPU_CTRL_DEVICE_ID,
+ 7,
+ vector<struct resource_attr_info> {
+ { .attr_id = RESOURCE_MONITOR_GPU_ATTR_CUR_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_GPU_ATTR_MIN_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_GPU_ATTR_MAX_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_GPU_ATTR_AVAILABLE_MIN_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_GPU_ATTR_AVAILABLE_MAX_FREQ, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_GPU_ATTR_CUR_GOVERNOR, .attr_type = DATA_TYPE_STRING, },
+ { .attr_id = RESOURCE_MONITOR_GPU_ATTR_NAME, .attr_type = DATA_TYPE_STRING, },
+ }
+ ),
+
+ PhysicalResourceInfo (
+ RESOURCE_TYPE_MEMORY,
+ "RESOURCE_TYPE_MEMORY",
+ -1,
+ -1,
+ 0,
+ 0,
+ 9,
+ vector<struct resource_attr_info> {
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_TOTAL, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_AVAILABLE, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_FREE, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_BUFFER, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_CACHED, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_CMA_TOTAL, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_CMA_FREE, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_SWAP_TOTAL, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_MEMORY_ATTR_SWAP_FREE, .attr_type = DATA_TYPE_UINT64, },
+ }
+ ),
+
+ PhysicalResourceInfo (
+ RESOURCE_TYPE_BATTERY,
+ "RESOURCE_TYPE_BATTERY",
+ -1,
+ -1,
+ 0,
+ 0,
+ 7,
+ vector<struct resource_attr_info> {
+ { .attr_id = RESOURCE_MONITOR_BATTERY_ATTR_CAPACITY, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BATTERY_ATTR_STATUS, .attr_type = DATA_TYPE_STRING, },
+ { .attr_id = RESOURCE_MONITOR_BATTERY_ATTR_TEMPERATURE, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BATTERY_ATTR_VOLTAGE_NOW, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BATTERY_ATTR_CURRENT_NOW, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BATTERY_ATTR_PRESENT, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_BATTERY_ATTR_ONLINE, .attr_type = DATA_TYPE_INT, },
+ }
+ ),
+
+ PhysicalResourceInfo (
+ RESOURCE_TYPE_DISPLAY,
+ "RESOURCE_TYPE_DISPLAY",
+ -1,
+ -1,
+ 0,
+ DISPLAY_CTRL_DEVICE_ID,
+ 2,
+ vector<struct resource_attr_info> {
+ { .attr_id = RESOURCE_MONITOR_DISPLAY_ATTR_FPS, .attr_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_DISPLAY_ATTR_NAME, .attr_type = DATA_TYPE_STRING, },
+ }
+ ),
+
+ PhysicalResourceInfo (
+ RESOURCE_TYPE_SYSTEM,
+ "RESOURCE_TYPE_SYSTEM",
+ -1,
+ -1,
+ 0,
+ 0,
+ 8,
+ vector<struct resource_attr_info> {
+ { .attr_id = RESOURCE_MONITOR_SYSTEM_ATTR_CPU_UTIL, .attr_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_SYSTEM_ATTR_CPU_USER_UTIL, .attr_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_SYSTEM_ATTR_CPU_SYS_UTIL, .attr_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_SYSTEM_ATTR_PER_CPU_UTIL, .attr_type = DATA_TYPE_ARRAY, .array_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_SYSTEM_ATTR_PER_CPU_USER_UTIL, .attr_type = DATA_TYPE_ARRAY, .array_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_SYSTEM_ATTR_PER_CPU_SYS_UTIL, .attr_type = DATA_TYPE_ARRAY, .array_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_SYSTEM_ATTR_POSSIBLE_CPU, .attr_type = DATA_TYPE_INT, },
+ { .attr_id = RESOURCE_MONITOR_SYSTEM_ATTR_ONLINE_CPU, .attr_type = DATA_TYPE_INT, },
+ }
+ ),
+
+ PhysicalResourceInfo (
+ RESOURCE_TYPE_DISK,
+ "RESOURCE_TYPE_DISK",
+ -1,
+ -1,
+ 0,
+ DISK_CTRL_DEVICE_ID,
+ 5,
+ vector<struct resource_attr_info> {
+ { .attr_id = RESOURCE_MONITOR_DISK_ATTR_NAME, .attr_type = DATA_TYPE_STRING, },
+ { .attr_id = RESOURCE_MONITOR_DISK_ATTR_READ_PER_SEC, .attr_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_DISK_ATTR_WRITE_PER_SEC, .attr_type = DATA_TYPE_DOUBLE, },
+ { .attr_id = RESOURCE_MONITOR_DISK_ATTR_READ_TOTAL, .attr_type = DATA_TYPE_UINT64, },
+ { .attr_id = RESOURCE_MONITOR_DISK_ATTR_WRITE_TOTAL, .attr_type = DATA_TYPE_UINT64, },
+ }
+ )
+));
+
+TEST_P(PhysicalResourceMonitorTest, resource_monitor_create_resource_and_delete)
+{
+ auto res = GetParam();
+ int i;
+
+ res.mon_id = resource_monitor_init();
+ ASSERT_TRUE(res.mon_id > 0);
+
+ int ret = resource_monitor_get_resource_count(res.mon_id, res.type, &res.count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < res.count; i++) {
+ /* Test resource_monitor_create_resource */
+ res.res_id = resource_monitor_create_resource(res.mon_id, res.type);
+ EXPECT_TRUE(res.res_id >= 0);
+
+ /* Test resource_monitor_delete_resource */
+ ret = resource_monitor_delete_resource(res.mon_id, res.res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ resource_monitor_exit(res.mon_id);
+}
+
+TEST_P(PhysicalResourceMonitorTest, resource_monitor_get_resource_timestamp)
+{
+ auto res = GetParam();
+ int i;
+
+ res.mon_id = resource_monitor_init();
+ ASSERT_TRUE(res.mon_id > 0);
+
+ int ret = resource_monitor_get_resource_count(res.mon_id, res.type, &res.count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < res.count; i++) {
+ int64_t start, end;
+
+ res.res_id = resource_monitor_create_resource(res.mon_id, res.type);
+ EXPECT_TRUE(res.res_id >= 0);
+
+ /* Test resource_monitor_get_resource_timestamp */
+ ret = resource_monitor_get_resource_timestamp(
+ res.mon_id, res.res_id,
+ &start, &end);
+ EXPECT_EQ(ret, 0);
+
+ ret = resource_monitor_delete_resource(res.mon_id, res.res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ resource_monitor_exit(res.mon_id);
+}
+
+TEST_P(PhysicalResourceMonitorTest, resource_monitor_set_resource_ctrl)
+{
+ auto res = GetParam();
+ int i;
+
+ res.mon_id = resource_monitor_init();
+ ASSERT_TRUE(res.mon_id > 0);
+
+ int ret = resource_monitor_get_resource_count(res.mon_id, res.type, &res.count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < res.count; i++) {
+ res.res_id = resource_monitor_create_resource(res.mon_id, res.type);
+ EXPECT_TRUE(res.res_id >= 0);
+
+ /* Test resource_monitor_set_resource_ctrl */
+ ret = resource_monitor_set_resource_ctrl(res.mon_id, res.res_id,
+ res.ctrl_id, i);
+ if (res.ctrl_id > 0)
+ EXPECT_EQ(ret, 0);
+ else
+ EXPECT_NE(ret, 0);
+
+ ret = resource_monitor_delete_resource(res.mon_id, res.res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ ret = resource_monitor_exit(res.mon_id);
+ EXPECT_EQ(ret, 0);
+}
+
+static int __resource_monitor_set_resource_attr(int mon_id, int res_id, int num_attrs,
+ std::vector<struct resource_attr_info> attrs)
+{
+ int i, ret;
+ u_int64_t mask = 0;
+
+ for (i = 0; i < num_attrs; i++) {
+ bool supported;
+
+ ret = resource_monitor_is_resource_attr_supported(
+ mon_id, res_id,
+ attrs[i].attr_id,
+ &supported);
+ EXPECT_EQ(ret, 0);
+
+ if (supported)
+ mask |= attrs[i].attr_id;
+ }
+
+ ret = resource_monitor_set_resource_attr(mon_id, res_id, mask);
+ EXPECT_EQ(ret, 0);
+
+ return ret;
+}
+
+static int __resource_monitor_unset_resource_attr(int mon_id, int res_id, int num_attrs,
+ std::vector<struct resource_attr_info> attrs)
+{
+ int i, ret;
+ u_int64_t mask = 0;
+
+ for (i = 0; i < num_attrs; i++) {
+ bool supported;
+
+ ret = resource_monitor_is_resource_attr_supported(
+ mon_id, res_id,
+ attrs[i].attr_id,
+ &supported);
+ EXPECT_EQ(ret, 0);
+
+ if (supported)
+ mask |= attrs[i].attr_id;
+ }
+
+ ret = resource_monitor_unset_resource_attr(mon_id, res_id, mask);
+ EXPECT_EQ(ret, 0);
+
+ return ret;
+}
+
+static bool __resource_monitor_is_resource_attr_set(int mon_id, int res_id, int num_attrs,
+ std::vector<struct resource_attr_info> attrs)
+{
+ int i, ret;
+ u_int64_t mask = 0;
+
+ for (i = 0; i < num_attrs; i++) {
+ bool supported;
+
+ ret = resource_monitor_is_resource_attr_supported(
+ mon_id, res_id,
+ attrs[i].attr_id,
+ &supported);
+ EXPECT_EQ(ret, 0);
+
+ if (supported)
+ mask |= attrs[i].attr_id;
+ }
+
+ ret = resource_monitor_set_resource_attr(mon_id, res_id, mask);
+ EXPECT_EQ(ret, 0);
+
+ bool set = resource_monitor_is_resource_attr_set(mon_id, res_id, mask);
+ EXPECT_EQ(set, true);
+
+ return set;
+}
+
+TEST_P(PhysicalResourceMonitorTest, resource_monitor_set_resource_attr)
+{
+ auto res = GetParam();
+ int i;
+
+ res.mon_id = resource_monitor_init();
+ ASSERT_TRUE(res.mon_id > 0);
+
+ int ret = resource_monitor_get_resource_count(res.mon_id, res.type, &res.count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < res.count; i++) {
+ res.res_id = resource_monitor_create_resource(res.mon_id, res.type);
+ EXPECT_TRUE(res.res_id >= 0);
+
+ /*
+ * Test both resource_monitor_set_resource_attr
+ * and resource_monitor_is_resource_attr_supported
+ * */
+ ret = resource_monitor_set_resource_ctrl(res.mon_id, res.res_id,
+ res.ctrl_id, i);
+ if (res.ctrl_id > 0)
+ EXPECT_EQ(ret, 0);
+ else
+ EXPECT_NE(ret, 0);
+
+ ret = __resource_monitor_set_resource_attr(res.mon_id,
+ res.res_id,
+ res.num_attrs,
+ res.attrs);
+ EXPECT_EQ(ret, 0);
+
+ ret = resource_monitor_delete_resource(res.mon_id, res.res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ ret = resource_monitor_exit(res.mon_id);
+ EXPECT_EQ(ret, 0);
+}
+
+TEST_P(PhysicalResourceMonitorTest, resource_monitor_unset_resource_attr_valid)
+{
+ auto res = GetParam();
+ int i;
+
+ res.mon_id = resource_monitor_init();
+ ASSERT_TRUE(res.mon_id > 0);
+
+ int ret = resource_monitor_get_resource_count(res.mon_id, res.type, &res.count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < res.count; i++) {
+ res.res_id = resource_monitor_create_resource(res.mon_id, res.type);
+ EXPECT_TRUE(res.res_id >= 0);
+
+ ret = resource_monitor_set_resource_ctrl(res.mon_id, res.res_id,
+ res.ctrl_id, i);
+ if (res.ctrl_id > 0)
+ EXPECT_EQ(ret, 0);
+ else
+ EXPECT_NE(ret, 0);
+
+ ret = __resource_monitor_set_resource_attr(res.mon_id,
+ res.res_id,
+ res.num_attrs,
+ res.attrs);
+ EXPECT_EQ(ret, 0);
+
+ /* Test resource_monitor_unset_resource_attr */
+ ret = __resource_monitor_unset_resource_attr(res.mon_id,
+ res.res_id,
+ res.num_attrs,
+ res.attrs);
+ EXPECT_EQ(ret, 0);
+
+ ret = resource_monitor_delete_resource(res.mon_id, res.res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ ret = resource_monitor_exit(res.mon_id);
+ EXPECT_EQ(ret, 0);
+}
+
+TEST_P(PhysicalResourceMonitorTest, resource_monitor_unset_resource_attr_invalid)
+{
+ auto res = GetParam();
+ int i;
+
+ res.mon_id = resource_monitor_init();
+ ASSERT_TRUE(res.mon_id > 0);
+
+ int ret = resource_monitor_get_resource_count(res.mon_id, res.type, &res.count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < res.count; i++) {
+ res.res_id = resource_monitor_create_resource(res.mon_id, res.type);
+ EXPECT_TRUE(res.res_id >= 0);
+
+ ret = resource_monitor_set_resource_ctrl(res.mon_id, res.res_id,
+ res.ctrl_id, i);
+ if (res.ctrl_id > 0)
+ EXPECT_EQ(ret, 0);
+ else
+ EXPECT_NE(ret, 0);
+
+ ret = __resource_monitor_set_resource_attr(res.mon_id,
+ res.res_id,
+ res.num_attrs,
+ res.attrs);
+ EXPECT_EQ(ret, 0);
+
+ /* Test resource_monitor_unset_resource_attr */
+ ret = resource_monitor_unset_resource_attr(res.mon_id,
+ res.res_id,
+ UNKNOWN_ATTR_MASK);
+ EXPECT_NE(ret, 0);
+
+ ret = resource_monitor_delete_resource(res.mon_id, res.res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ ret = resource_monitor_exit(res.mon_id);
+ EXPECT_EQ(ret, 0);
+}
+
+TEST_P(PhysicalResourceMonitorTest, resource_monitor_is_resource_attr_set)
+{
+ auto res = GetParam();
+ int i;
+
+ res.mon_id = resource_monitor_init();
+ ASSERT_TRUE(res.mon_id > 0);
+
+ int ret = resource_monitor_get_resource_count(res.mon_id, res.type, &res.count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < res.count; i++) {
+ res.res_id = resource_monitor_create_resource(res.mon_id, res.type);
+ EXPECT_TRUE(res.res_id >= 0);
+
+ ret = resource_monitor_set_resource_ctrl(res.mon_id, res.res_id,
+ res.ctrl_id, i);
+ if (res.ctrl_id > 0)
+ EXPECT_EQ(ret, 0);
+ else
+ EXPECT_NE(ret, 0);
+
+ /* Test resource_monitor_is_resource_attr_set */
+ bool set = __resource_monitor_is_resource_attr_set(res.mon_id,
+ res.res_id,
+ res.num_attrs,
+ res.attrs);
+ EXPECT_EQ(set, true);
+
+ ret = resource_monitor_delete_resource(res.mon_id, res.res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ ret = resource_monitor_exit(res.mon_id);
+ EXPECT_EQ(ret, 0);
+}
+
+static int __resource_monitor_get_value(int mon_id, int res_id, int num_attrs,
+ std::vector<struct resource_attr_info> attrs)
+{
+ int i, ret, err_count = 0;
+
+ for (i = 0; i < num_attrs; i++) {
+ bool supported;
+
+ ret = resource_monitor_is_resource_attr_supported(
+ mon_id, res_id,
+ attrs[i].attr_id,
+ &supported);
+ if (!supported)
+ continue;
+
+ switch (attrs[i].attr_type) {
+ case DATA_TYPE_INT:
+ int32_t value_int32;
+ ret = resource_monitor_get_value_int(mon_id, res_id,
+ attrs[i].attr_id, &value_int32);
+ EXPECT_EQ(ret, 0);
+ break;
+ case DATA_TYPE_INT64:
+ int64_t value_int64;
+ ret = resource_monitor_get_value_int64(mon_id, res_id,
+ attrs[i].attr_id, &value_int64);
+ EXPECT_EQ(ret, 0);
+ break;
+ case DATA_TYPE_UINT:
+ u_int32_t value_uint32;
+ ret = resource_monitor_get_value_uint(mon_id, res_id,
+ attrs[i].attr_id, &value_uint32);
+ EXPECT_EQ(ret, 0);
+ break;
+ case DATA_TYPE_UINT64:
+ u_int64_t value_uint64;
+ ret = resource_monitor_get_value_uint64(mon_id, res_id,
+ attrs[i].attr_id, &value_uint64);
+ EXPECT_EQ(ret, 0);
+ break;
+ case DATA_TYPE_DOUBLE:
+ double value_double;
+ ret = resource_monitor_get_value_double(mon_id, res_id,
+ attrs[i].attr_id, &value_double);
+ EXPECT_EQ(ret, 0);
+ break;
+ case DATA_TYPE_STRING:
+ {
+ char *value_str = NULL;
+ ret = resource_monitor_get_value_string(mon_id, res_id,
+ attrs[i].attr_id, &value_str);
+ g_free(value_str);
+ EXPECT_EQ(ret, 0);
+ break;
+ }
+ case DATA_TYPE_ARRAY:
+ int length;
+
+ switch (attrs[i].array_type) {
+ case DATA_TYPE_INT:
+ {
+ int32_t *array = NULL;
+ ret = resource_monitor_get_array_int(mon_id, res_id,
+ attrs[i].attr_id, &array, &length);
+ EXPECT_EQ(ret, 0);
+ break;
+ }
+ case DATA_TYPE_INT64:
+ {
+ int64_t *array = NULL;;
+ ret = resource_monitor_get_array_int64(mon_id, res_id,
+ attrs[i].attr_id, &array, &length);
+ EXPECT_EQ(ret, 0);
+ break;
+ }
+ case DATA_TYPE_UINT:
+ {
+ u_int32_t *array = NULL;
+ ret = resource_monitor_get_array_uint(mon_id, res_id,
+ attrs[i].attr_id, &array, &length);
+ EXPECT_EQ(ret, 0);
+ break;
+ }
+ case DATA_TYPE_UINT64:
+ {
+ u_int64_t *array = NULL;
+ ret = resource_monitor_get_array_uint64(mon_id, res_id,
+ attrs[i].attr_id, &array, &length);
+ EXPECT_EQ(ret, 0);
+ break;
+ }
+ case DATA_TYPE_DOUBLE:
+ {
+ double *array = NULL;
+ ret = resource_monitor_get_array_double(mon_id, res_id,
+ attrs[i].attr_id, &array, &length);
+ EXPECT_EQ(ret, 0);
+ break;
+ }
+ case DATA_TYPE_STRING:
+ {
+ char **array = NULL;
+ ret = resource_monitor_get_array_string(mon_id, res_id,
+ attrs[i].attr_id, &array, &length);
+ EXPECT_EQ(ret, 0);
+ break;
+ }
+ default:
+ {
+ /* Unknown data type */
+ ret = -EINVAL;
+ EXPECT_TRUE(false);
+ }
+ }
+ break;
+ default:
+ /* Unknown data type */
+ ret = -EINVAL;
+ EXPECT_TRUE(false);
+ break;
+ }
+
+ if (ret < 0)
+ err_count++;
+ }
+
+ return err_count ? -EINVAL : 0;
+}
+
+TEST_P(PhysicalResourceMonitorTest, resource_monitor_get_value)
+{
+ auto res = GetParam();
+ int i;
+
+ res.mon_id = resource_monitor_init();
+ ASSERT_TRUE(res.mon_id > 0);
+
+ int ret = resource_monitor_get_resource_count(res.mon_id, res.type, &res.count);
+ EXPECT_EQ(ret, 0);
+
+ for (i = 0; i < res.count; i++) {
+ res.res_id = resource_monitor_create_resource(res.mon_id, res.type);
+ EXPECT_TRUE(res.res_id >= 0);
+
+ ret = resource_monitor_set_resource_ctrl(res.mon_id, res.res_id,
+ res.ctrl_id, i);
+ if (res.ctrl_id > 0)
+ EXPECT_EQ(ret, 0);
+ else
+ EXPECT_NE(ret, 0);
+
+ ret = __resource_monitor_set_resource_attr(res.mon_id,
+ res.res_id,
+ res.num_attrs,
+ res.attrs);
+ EXPECT_EQ(ret, 0);
+
+ /*
+ * Test both resource_monitor_update
+ * and resource_monitor_get_value_[data type]
+ */
+ ret = resource_monitor_update(res.mon_id);
+ EXPECT_EQ(ret, 0);
+
+ ret = __resource_monitor_get_value(res.mon_id,
+ res.res_id,
+ res.num_attrs,
+ res.attrs);
+ EXPECT_EQ(ret, 0);
+
+ ret = resource_monitor_delete_resource(res.mon_id, res.res_id);
+ EXPECT_EQ(ret, 0);
+ }
+
+ ret = resource_monitor_exit(res.mon_id);
+ EXPECT_EQ(ret, 0);
+}
+
+int main(int argc, char *argv[])
+{
+ try {
+ testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+ } catch (...) {
+ return EXIT_FAILURE;
+ }
+}
projects / platform / core / api / resource-monitor.git / commitdiff