1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
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 #include "hidumper_service_test.h"
16 #include <iservice_registry.h>
17 #include "common.h"
18 #include "hilog_wrapper.h"
19 #include "dump_callback_broker_stub.h"
20 #include "dump_manager_client.h"
21 #include "raw_param.h"
22 #include "dump_manager_service.h"
23 #include "inner/dump_service_id.h"
24 #include "hidumper_test_default_callback.h"
25 using namespace std;
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::HiviewDFX;
29 namespace OHOS {
30 namespace HiviewDFX {
31 namespace {
32 static const int TEST_LOOP = 100;
33 static const int TASK_WAITTIME_MAX = 1;
34 static const int TASK_REQUEST_MAX = 1000;
35 static const int TASK_WAIT_ONETIME = 100;
36 static const std::string TEST_ARGV_0 = "hidumper";
37 static const std::string TEST_ARGV_1 = "-h";
38 static int g_TaskOutfd = -1;
39 static std::vector<std::string> g_TaskArgs;
40 static IDumpCallbackBroker* g_TaskCallback;
41 }
SetUpTestCase(void)42 void HidumperServiceTest::SetUpTestCase(void)
43 {
44 }
45
TearDownTestCase(void)46 void HidumperServiceTest::TearDownTestCase(void)
47 {
48 }
49
SetUp(void)50 void HidumperServiceTest::SetUp(void)
51 {
52 }
53
TearDown(void)54 void HidumperServiceTest::TearDown(void)
55 {
56 }
57
58 /**
59 * @tc.name: HidumperServiceTest001
60 * @tc.desc: Test DumpManagerService service ready.
61 * @tc.type: FUNC
62 */
63 HWTEST_F (HidumperServiceTest, HidumperServiceTest001, TestSize.Level3)
64 {
65 auto dmsTest = DelayedSpSingleton<DumpManagerService>::GetInstance();
66 dmsTest->OnStart();
67 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
68 ASSERT_TRUE(sam != nullptr) << "HidumperServiceTest001 fail to get GetSystemAbilityManager";
69 sptr<IRemoteObject> remoteObject = sam->CheckSystemAbility(DFX_SYS_HIDUMPER_ABILITY_ID);
70 ASSERT_TRUE(remoteObject != nullptr) << "GetSystemAbility failed.";
71 dmsTest->OnStop();
72 }
73
74 /**
75 * @tc.name: HidumperServiceTest002
76 * @tc.desc: Test DumpManagerService Start and stop.
77 * @tc.type: FUNC
78 */
79 HWTEST_F (HidumperServiceTest, HidumperServiceTest002, TestSize.Level3)
80 {
81 auto dmsTest = DelayedSpSingleton<DumpManagerService>::GetInstance();
82 ASSERT_TRUE(dmsTest != nullptr) << "HidumperServiceTest002 fail to get DumpManagerService";
83 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "SetUpTestCase dmsTest is ready";
84 dmsTest->OnStart();
85 ASSERT_TRUE(dmsTest->IsServiceStarted()) << "SetUpTestCase dmsTest is not ready";
86 dmsTest->OnStop();
87 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "SetUpTestCase dmsTest stop fail";
88 dmsTest->OnStart();
89 ASSERT_TRUE(dmsTest->IsServiceStarted()) << "SetUpTestCase dmsTest is not ready";
90 dmsTest->OnStop();
91 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "SetUpTestCase dmsTest stop fail";
92 }
93
94 /**
95 * @tc.name: HidumperServiceTest003
96 * @tc.desc: Test DumpManagerService Request.
97 * @tc.type: FUNC
98 */
99 HWTEST_F (HidumperServiceTest, HidumperServiceTest003, TestSize.Level3)
100 {
101 // prepare request data
102 std::vector<std::u16string> args = {
103 Str8ToStr16(TEST_ARGV_0), Str8ToStr16(TEST_ARGV_1),
104 };
105 int outfd = -1;
106 uint32_t statusStart = IDumpCallbackBroker::STATUS_INIT;
107 uint32_t statusFinish = IDumpCallbackBroker::STATUS_INIT;
108 uint32_t statusError = IDumpCallbackBroker::STATUS_INIT;
109 sptr<IDumpCallbackBroker> callback = sptr<IDumpCallbackBroker>(new HidumperTestDefaultCallback(statusStart,
110 statusFinish, statusError));
111 // start service
112 auto dmsTest = DelayedSpSingleton<DumpManagerService>::GetInstance();
113 ASSERT_TRUE(dmsTest != nullptr) << "Fail to get DumpManagerService";
114 dmsTest->OnStart();
115 ASSERT_TRUE(dmsTest->IsServiceStarted()) << "DumpManagerService isn't ready";
116 // set dummy function
__anon7bb539d60202(int argc, char *argv[], const std::shared_ptr<RawParam>& rawParam) 117 dmsTest->SetTestMainFunc([=] (int argc, char *argv[], const std::shared_ptr<RawParam>& rawParam) {
118 for (int i = 0; ((!rawParam->IsCanceled()) && (i < TASK_WAITTIME_MAX)); i++) {
119 usleep(TASK_WAIT_ONETIME);
120 }
121 });
122 // request
123 int res = dmsTest->Request(args, outfd, callback);
124 EXPECT_EQ(res, DumpStatus::DUMP_OK);
125 // stop service
126 dmsTest->OnStop();
127 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "DumpManagerService stop fail";
128 // check result
129 EXPECT_EQ(statusStart, IDumpCallbackBroker::STATUS_DUMP_STARTED);
130 EXPECT_EQ(statusFinish, IDumpCallbackBroker::STATUS_DUMP_FINISHED);
131 ASSERT_EQ(statusError, IDumpCallbackBroker::STATUS_INIT);
132 }
133
134 /**
135 * @tc.name: HidumperServiceTest004
136 * @tc.desc: Test DumpManagerService Request argument.
137 * @tc.type: FUNC
138 */
139 HWTEST_F (HidumperServiceTest, HidumperServiceTest004, TestSize.Level3)
140 {
141 // prepare request data
142 std::vector<std::u16string> args = {
143 Str8ToStr16(TEST_ARGV_0), Str8ToStr16(TEST_ARGV_1),
144 };
145 int outfd = -100;
146 uint32_t statusStart = IDumpCallbackBroker::STATUS_INIT;
147 uint32_t statusFinish = IDumpCallbackBroker::STATUS_INIT;
148 uint32_t statusError = IDumpCallbackBroker::STATUS_INIT;
149 sptr<IDumpCallbackBroker> callback = sptr<IDumpCallbackBroker>(new HidumperTestDefaultCallback(statusStart,
150 statusFinish, statusError));
151 // start service
152 auto dmsTest = DelayedSpSingleton<DumpManagerService>::GetInstance();
153 ASSERT_TRUE(dmsTest != nullptr) << "Fail to get DumpManagerService";
154 dmsTest->OnStart();
155 ASSERT_TRUE(dmsTest->IsServiceStarted()) << "DumpManagerService isn't ready";
156 // set dummy function to get data
__anon7bb539d60302(int argc, char *argv[], const std::shared_ptr<RawParam>& rawParam) 157 dmsTest->SetTestMainFunc([=] (int argc, char *argv[], const std::shared_ptr<RawParam>& rawParam) {
158 g_TaskOutfd = rawParam->GetOutputFd();
159 const sptr<IDumpCallbackBroker> cb = rawParam->GetCallback();
160 if (cb != nullptr) {
161 g_TaskCallback = cb.GetRefPtr();
162 }
163 for (int i = 0; ((argv != nullptr) && (i < argc)); i++) {
164 g_TaskArgs.push_back(std::string(argv[i]));
165 }
166 for (int i = 0; ((!rawParam->IsCanceled()) && (i < TASK_WAITTIME_MAX)); i++) {
167 usleep(TASK_WAIT_ONETIME);
168 }
169 });
170 g_TaskOutfd = -1;
171 g_TaskArgs.clear();
172 g_TaskCallback = nullptr;
173 // request
174 int res = dmsTest->Request(args, outfd, callback);
175 EXPECT_EQ(res, DumpStatus::DUMP_OK);
176 // stop service
177 sleep(1);
178 dmsTest->OnStop();
179 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "DumpManagerService stop fail";
180 // check result
181 EXPECT_EQ(args.size(), g_TaskArgs.size());
182 for (size_t i = 0; i < args.size(); i++) {
183 EXPECT_EQ(Str16ToStr8(args[i]), g_TaskArgs[i]);
184 }
185 EXPECT_EQ(outfd, g_TaskOutfd);
186 ASSERT_EQ(g_TaskCallback, callback);
187 }
188
189 /**
190 * @tc.name: HidumperServiceTest005
191 * @tc.desc: Test DumpManagerService Request Max.
192 * @tc.type: FUNC
193 */
194 HWTEST_F (HidumperServiceTest, HidumperServiceTest005, TestSize.Level3)
195 {
196 // prepare request data
197 uint32_t statusStart = IDumpCallbackBroker::STATUS_INIT;
198 uint32_t statusFinish = IDumpCallbackBroker::STATUS_INIT;
199 uint32_t statusError = IDumpCallbackBroker::STATUS_INIT;
200 std::vector<std::u16string> args = {
201 Str8ToStr16(TEST_ARGV_0), Str8ToStr16(TEST_ARGV_1),
202 };
203 int outfd = -1;
204 sptr<IDumpCallbackBroker> callback = sptr<IDumpCallbackBroker>(new HidumperTestDefaultCallback(statusStart,
205 statusFinish, statusError));
206 // start service
207 auto dmsTest = DelayedSpSingleton<DumpManagerService>::GetInstance();
208 ASSERT_TRUE(dmsTest != nullptr) << "Fail to get DumpManagerService";
209 dmsTest->OnStart();
210 ASSERT_TRUE(dmsTest->IsServiceStarted()) << "DumpManagerService isn't ready";
211 // set dummy function
__anon7bb539d60402(int argc, char *argv[], const std::shared_ptr<RawParam>& rawParam) 212 dmsTest->SetTestMainFunc([=] (int argc, char *argv[], const std::shared_ptr<RawParam>& rawParam) {
213 for (int i = 0; ((!rawParam->IsCanceled()) && (i < TASK_WAITTIME_MAX)); i++) {
214 usleep(TASK_WAIT_ONETIME);
215 }
216 });
217 bool requestOk = false;
218 bool requestMax = false;
219 bool requestError = false;
220 // request
221 for (int i = 0; i < TASK_REQUEST_MAX; i++) {
222 int res = dmsTest->Request(args, outfd, callback);
223 if (res == DumpStatus::DUMP_OK) {
224 requestOk = true;
225 continue;
226 } else if (res == DumpStatus::DUMP_REQUEST_MAX) {
227 requestMax = true;
228 break;
229 }
230 requestError = true;
231 break;
232 }
233 // stop service
234 dmsTest->OnStop();
235 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "DumpManagerService stop fail";
236 // check result
237 ASSERT_TRUE(requestOk);
238 ASSERT_TRUE(!requestError);
239 }
240
241 /**
242 * @tc.name: HidumperServiceTest006
243 * @tc.desc: Loop to Test DumpManagerService start & stop.
244 * @tc.type: FUNC
245 */
246 HWTEST_F (HidumperServiceTest, HidumperServiceTest006, TestSize.Level3)
247 {
248 // loop to start & stop
249 for (int i = 0; i < TEST_LOOP; i++) {
250 auto dmsTest = DelayedSpSingleton<DumpManagerService>::GetInstance();
251 ASSERT_TRUE(dmsTest != nullptr) << "Fail to get DumpManagerService";
252 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "dmsTest isn't ready";
253 dmsTest->OnStart();
254 ASSERT_TRUE(dmsTest->IsServiceStarted()) << "dmsTest is ready";
255 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
256 ASSERT_TRUE(sam != nullptr) << "Fail to get GetSystemAbilityManager";
257 sptr<IRemoteObject> remoteObject = sam->CheckSystemAbility(DFX_SYS_HIDUMPER_ABILITY_ID);
258 ASSERT_TRUE(remoteObject != nullptr) << "GetSystemAbility failed.";
259 dmsTest->OnStop();
260 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "dmsTest isn't ready";
261 }
262 }
263
264 /**
265 * @tc.name: HidumperServiceTest007
266 * @tc.desc: Loop to Test DumpManagerService Request.
267 * @tc.type: FUNC
268 */
269 HWTEST_F (HidumperServiceTest, HidumperServiceTest007, TestSize.Level3)
270 {
271 // prepare request data
272 uint32_t statusStart = IDumpCallbackBroker::STATUS_INIT;
273 uint32_t statusFinish = IDumpCallbackBroker::STATUS_INIT;
274 uint32_t statusError = IDumpCallbackBroker::STATUS_INIT;
275 std::vector<std::u16string> args = {
276 Str8ToStr16(TEST_ARGV_0), Str8ToStr16(TEST_ARGV_1),
277 };
278 int outfd = -1;
279 sptr<IDumpCallbackBroker> callback = sptr<IDumpCallbackBroker>(new HidumperTestDefaultCallback(statusStart,
280 statusFinish, statusError));
281 // start service
282 auto dmsTest = DelayedSpSingleton<DumpManagerService>::GetInstance();
283 ASSERT_TRUE(dmsTest != nullptr) << "Fail to get DumpManagerService";
284 dmsTest->OnStart();
285 ASSERT_TRUE(dmsTest->IsServiceStarted()) << "DumpManagerService isn't ready";
286 // set dummy function
__anon7bb539d60502(int argc, char *argv[], const std::shared_ptr<RawParam>& rawParam) 287 dmsTest->SetTestMainFunc([=] (int argc, char *argv[], const std::shared_ptr<RawParam>& rawParam) {
288 usleep(TASK_WAIT_ONETIME);
289 });
290 // loop to request
291 bool hasError = false;
292 int hasErrorCode = 0;
293 int hasErrorIndex = 0;
294 for (int i = 0; i < TEST_LOOP; i++) {
295 int res = dmsTest->Request(args, outfd, callback);
296 if (res == DumpStatus::DUMP_OK) {
297 usleep(TASK_WAIT_ONETIME);
298 continue;
299 } else if (res == DumpStatus::DUMP_REQUEST_MAX) {
300 usleep(TASK_WAIT_ONETIME);
301 continue;
302 }
303 hasError = true;
304 hasErrorCode = res;
305 hasErrorIndex = i;
306 break;
307 }
308 // stop service
309 dmsTest->OnStop();
310 ASSERT_TRUE(!dmsTest->IsServiceStarted()) << "DumpManagerService stop fail";
311 // check result
312 ASSERT_TRUE(!hasError) << "request error, times = " << hasErrorIndex << ", res = " << hasErrorCode;
313 }
314 } // namespace HiviewDFX
315 } // namespace OHOS