1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstring>
17 #include <dlfcn.h>
18 #include <fcntl.h>
19 #include <gtest/gtest.h>
20 #include <cinttypes>
21 #include <cstdio>
22 #include <ctime>
23 #include <unistd.h>
24
25 #include "hidump_plugin.h"
26 #include "plugin_module_api.h"
27
28 using namespace testing::ext;
29
30 namespace {
31 const std::string DEFAULT_RECORD_FILE("/data/local/tmp/");
32 const int DEFAULT_WAIT = 10;
33
34 class HidumpPluginUnittest : public ::testing::Test {
35 public:
SetUpTestCase()36 static void SetUpTestCase() {};
TearDownTestCase()37 static void TearDownTestCase() {};
38
SetUp()39 void SetUp() {}
TearDown()40 void TearDown() {}
41 };
42
WriteFunc(WriterStruct * writer,const void * data,size_t size)43 long WriteFunc(WriterStruct* writer, const void* data, size_t size)
44 {
45 if (writer == nullptr || data == nullptr || size <= 0) {
46 return -1;
47 }
48
49 return 0;
50 }
51
FlushFunc(WriterStruct * writer)52 bool FlushFunc(WriterStruct* writer)
53 {
54 if (writer == nullptr) {
55 return false;
56 }
57 return true;
58 }
59
StartReportFunc(WriterStruct * writer)60 RandomWriteCtx* StartReportFunc(WriterStruct* writer)
61 {
62 return nullptr;
63 }
64
FinishReportFunc(WriterStruct * writer,int32_t size)65 void FinishReportFunc(WriterStruct* writer, int32_t size)
66 {
67 return;
68 }
69
PluginStart(HidumpPlugin & plugin,HidumpConfig & config)70 bool PluginStart(HidumpPlugin& plugin, HidumpConfig& config)
71 {
72 // serialize
73 int size = config.ByteSizeLong();
74 std::vector<uint8_t> configData(size);
75 int ret = config.SerializeToArray(configData.data(), configData.size());
76 CHECK_TRUE(ret > 0, false, "HidumpPluginUnittest: SerializeToArray fail!!!");
77 PROFILER_LOG_INFO(LOG_CORE, "HidumpPluginUnittest: SerializeToArray success");
78
79 // start
80 ret = plugin.Start(configData.data(), configData.size());
81 CHECK_TRUE(ret == 0, false, "HidumpPluginUnittest: start plugin fail!!!");
82 PROFILER_LOG_INFO(LOG_CORE, "HidumpPluginUnittest: Start success");
83
84 return true;
85 }
86
87 /**
88 * @tc.name: hidump plugin
89 * @tc.desc: Test framework
90 * @tc.type: FUNC
91 */
92 HWTEST_F(HidumpPluginUnittest, TestFramework, TestSize.Level1)
93 {
94 std::string path = std::string("libhidumpplugin.z.so");
95 void* handle = dlopen(path.c_str(), RTLD_LAZY);
96 EXPECT_NE(handle, nullptr);
97 PluginModuleStruct* plugin = reinterpret_cast<PluginModuleStruct*>(dlsym(handle, "g_pluginModule"));
98 EXPECT_NE(plugin, nullptr);
99 EXPECT_STREQ(plugin->name, "hidump-plugin");
100
101 // set config
102 HidumpConfig config;
103 config.set_report_fps(true);
104 int size = config.ByteSizeLong();
105 ASSERT_GT(size, 0);
106 std::vector<uint8_t> configData(size);
107 ASSERT_GT(config.SerializeToArray(configData.data(), configData.size()), 0);
108
109 // test framework process
110 WriterStruct writer = {WriteFunc, FlushFunc};
111 std::vector<uint8_t> dataBuffer(plugin->resultBufferSizeHint);
112 EXPECT_EQ(plugin->callbacks->onRegisterWriterStruct(&writer), 0);
113 EXPECT_EQ(plugin->callbacks->onPluginSessionStart(configData.data(), configData.size()), 0);
114 EXPECT_EQ(plugin->callbacks->onPluginSessionStop(), 0);
115 }
116
117 /**
118 * @tc.name: hidump plugin
119 * @tc.desc: Test if invalid cmd causes an exception
120 * expect："inaccessible or not found"
121 * @tc.type: FUNC
122 */
123 HWTEST_F(HidumpPluginUnittest, TestInvalidCmd1, TestSize.Level1)
124 {
125 HidumpConfig config;
126 HidumpPlugin plugin;
127 WriterStruct writer = {WriteFunc, FlushFunc};
128
129 config.set_report_fps(true);
130 plugin.SetConfig(config);
131
132 const char *cmd = "";
133 plugin.SetTestCmd(cmd);
134 plugin.SetWriter(&writer);
135 EXPECT_STREQ(plugin.GetTestCmd(), cmd);
136 EXPECT_TRUE(PluginStart(plugin, config));
137 EXPECT_EQ(plugin.Stop(), 0);
138 }
139
140 /**
141 * @tc.name: hidump plugin
142 * @tc.desc: Test if invalid cmd causes an exception
143 * expect："HidumpPlugin: fps command not output error!"
144 * @tc.type: FUNC
145 */
146 HWTEST_F(HidumpPluginUnittest, TestInvalidCmd2, TestSize.Level1)
147 {
148 HidumpConfig config;
149 HidumpPlugin plugin;
150 WriterStruct writer = {WriteFunc, FlushFunc};
151
152 config.set_report_fps(true);
153 plugin.SetConfig(config);
154
155 const char *cmd = "SP_daemon -profilerfps 0";
156 plugin.SetTestCmd(cmd);
157 plugin.SetWriter(&writer);
158 EXPECT_STREQ(plugin.GetTestCmd(), cmd);
159 EXPECT_TRUE(PluginStart(plugin, config));
160 EXPECT_EQ(plugin.Stop(), 0);
161 }
162
163 /**
164 * @tc.name: hidump plugin
165 * @tc.desc: Test Default Cmd
166 * @tc.type: FUNC
167 */
168 HWTEST_F(HidumpPluginUnittest, TestDefaultCmd, TestSize.Level1)
169 {
170 HidumpConfig config;
171 HidumpPlugin plugin;
172 WriterStruct writer = {WriteFunc, FlushFunc};
173
174 config.set_report_fps(true);
175 plugin.SetConfig(config);
176
177 plugin.SetWriter(&writer);
178 EXPECT_TRUE(PluginStart(plugin, config));
179 EXPECT_EQ(plugin.Stop(), 0);
180 }
181
182 /**
183 * @tc.name: hidump plugin
184 * @tc.desc: Test Default Cmd and verify result
185 * @tc.type: FUNC
186 */
187 HWTEST_F(HidumpPluginUnittest, TestCmdAndVerifyResult, TestSize.Level1)
188 {
189 HidumpConfig config;
190 HidumpPlugin plugin;
191 WriterStruct writer = {WriteFunc, FlushFunc};
192
193 config.set_report_fps(true);
194 plugin.SetConfig(config);
195
196 plugin.SetWriter(&writer);
197 EXPECT_TRUE(PluginStart(plugin, config));
198 sleep(DEFAULT_WAIT);
199 EXPECT_EQ(plugin.Stop(), 0);
200 }
201
202 /**
203 * @tc.name: hidump plugin
204 * @tc.desc: start fail test
205 * @tc.type: FUNC
206 */
207 HWTEST_F(HidumpPluginUnittest, TestStartFail, TestSize.Level1)
208 {
209 HidumpConfig config;
210 HidumpPlugin plugin;
211 WriterStruct writer = {WriteFunc, FlushFunc};
212
213 // set config
214 config.set_report_fps(true);
215
216 // test plugin process
217 plugin.SetWriter(&writer);
218 plugin.SetConfig(config);
219
220 // serialize
221 int size = config.ByteSizeLong();
222 ASSERT_GT(size, 0);
223 std::vector<uint8_t> configData(size);
224 ASSERT_GT(config.SerializeToArray(configData.data(), configData.size()), 0);
225
226 // start
227 EXPECT_NE(plugin.Start(configData.data(), size - 1), 0);
228 }
229
230 /**
231 * @tc.name: hidump plugin
232 * @tc.desc: Test pb encoder data
233 * @tc.type: FUNC
234 */
235 HWTEST_F(HidumpPluginUnittest, TestPbEncoderData, TestSize.Level1)
236 {
237 HidumpConfig config;
238 HidumpPlugin plugin;
239 WriterStruct writer = {WriteFunc, FlushFunc, StartReportFunc, FinishReportFunc, false};
240 config.set_report_fps(true);
241 plugin.SetConfig(config);
242 plugin.SetWriter(&writer);
243 EXPECT_TRUE(PluginStart(plugin, config));
244 sleep(DEFAULT_WAIT);
245 plugin.running_ = false;
246 EXPECT_EQ(plugin.Stop(), 0);
247 }
248
249 } // namespace