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
16 /* This files contains unit test for frame module. */
17
18 #include "process_frames_test.h"
19
20 #include <memory>
21
22 #include "dfx_frame.h"
23
24 using namespace OHOS::HiviewDFX;
25 using namespace testing::ext;
26 using namespace std;
27
SetUpTestCase(void)28 void ProcessFramesTest::SetUpTestCase(void)
29 {
30 }
31
32
TearDownTestCase(void)33 void ProcessFramesTest::TearDownTestCase(void)
34 {
35 }
36
SetUp(void)37 void ProcessFramesTest::SetUp(void)
38 {
39 }
40
TearDown(void)41 void ProcessFramesTest::TearDown(void)
42 {
43 }
44
45 namespace {
46 /**
47 * @tc.name: ProcessFrameTest001
48 * @tc.desc: test get frame index
49 * @tc.type: FUNC
50 */
51 HWTEST_F (ProcessFramesTest, ProcessFrameTest001, TestSize.Level2)
52 {
53 GTEST_LOG_(INFO) << "ProcessFrameTest001: start.";
54 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
55 size_t index = 1;
56 size_t frameIndex = 0;
57 if (frames != nullptr) {
58 frames->SetFrameIndex(index);
59 frameIndex = frames->GetFrameIndex();
60 }
61 EXPECT_EQ(true, index == frameIndex) << "ProcessFrameTest001 Failed";
62 GTEST_LOG_(INFO) << "ProcessFrameTest001: end.";
63 }
64
65 /**
66 * @tc.name: ProcessFrameTest002
67 * @tc.desc: test get frame index
68 * @tc.type: FUNC
69 */
70 HWTEST_F (ProcessFramesTest, ProcessFrameTest002, TestSize.Level2)
71 {
72 GTEST_LOG_(INFO) << "ProcessFrameTest002: start.";
73 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
74 size_t index = 164;
75 size_t frameIndex = 0;
76 if (frames != nullptr) {
77 frames->SetFrameIndex(index);
78 frameIndex = frames->GetFrameIndex();
79 }
80 EXPECT_EQ(true, index == frameIndex) << "ProcessFrameTest002 Failed";
81 GTEST_LOG_(INFO) << "ProcessFrameTest002: end.";
82 }
83
84 /**
85 * @tc.name: ProcessFrameTest003
86 * @tc.desc: test get frame index
87 * @tc.type: FUNC
88 */
89 HWTEST_F (ProcessFramesTest, ProcessFrameTest003, TestSize.Level2)
90 {
91 GTEST_LOG_(INFO) << "ProcessFrameTest003: start.";
92 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
93 size_t index = -1;
94 frames->SetFrameIndex(index);
95 size_t frameIndex = frames->GetFrameIndex();
96 EXPECT_EQ(true, index == frameIndex) << "ProcessFrameTest003 Failed";
97 GTEST_LOG_(INFO) << "ProcessFrameTest003: end.";
98 }
99
100 /**
101 * @tc.name: ProcessFrameTest004
102 * @tc.desc: test get frame func offset
103 * @tc.type: FUNC
104 */
105 HWTEST_F (ProcessFramesTest, ProcessFrameTest004, TestSize.Level2)
106 {
107 GTEST_LOG_(INFO) << "ProcessFrameTest004: start.";
108 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
109 uint64_t offset = 1;
110 frames->SetFrameFuncOffset(offset);
111 uint64_t frameOffset = frames->GetFrameFuncOffset();
112 EXPECT_EQ(true, offset == frameOffset) << "ProcessFrameTest004 Failed";
113 GTEST_LOG_(INFO) << "ProcessFrameTest004: end.";
114 }
115
116 /**
117 * @tc.name: ProcessFrameTest005
118 * @tc.desc: test get frame func offset
119 * @tc.type: FUNC
120 */
121 HWTEST_F (ProcessFramesTest, ProcessFrameTest005, TestSize.Level2)
122 {
123 GTEST_LOG_(INFO) << "ProcessFrameTest005: start.";
124 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
125 uint64_t offset = 164;
126 frames->SetFrameFuncOffset(offset);
127 uint64_t frameOffset = frames->GetFrameFuncOffset();
128 EXPECT_EQ(true, offset == frameOffset) << "ProcessFrameTest005 Failed";
129 GTEST_LOG_(INFO) << "ProcessFrameTest005: end.";
130 }
131
132 /**
133 * @tc.name: ProcessFrameTest006
134 * @tc.desc: test get frame func offset
135 * @tc.type: FUNC
136 */
137 HWTEST_F (ProcessFramesTest, ProcessFrameTest006, TestSize.Level2)
138 {
139 GTEST_LOG_(INFO) << "ProcessFrameTest006: start.";
140 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
141 uint64_t offset = -1;
142 frames->SetFrameFuncOffset(offset);
143 uint64_t frameOffset = frames->GetFrameFuncOffset();
144 EXPECT_EQ(true, offset == frameOffset) << "ProcessFrameTest006 Failed";
145 GTEST_LOG_(INFO) << "ProcessFrameTest006: end.";
146 }
147
148 /**
149 * @tc.name: ProcessFrameTest007
150 * @tc.desc: test get frame pc
151 * @tc.type: FUNC
152 */
153 HWTEST_F (ProcessFramesTest, ProcessFrameTest007, TestSize.Level2)
154 {
155 GTEST_LOG_(INFO) << "ProcessFrameTest007: start.";
156 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
157 uint64_t pc = 1;
158 uint64_t framePc = 0;
159 if (frames != nullptr) {
160 frames->SetFramePc(pc);
161 framePc = frames->GetFramePc();
162 }
163 EXPECT_EQ(true, pc == framePc) << "ProcessFrameTest007 Failed";
164 GTEST_LOG_(INFO) << "ProcessFrameTest007: end.";
165 }
166
167 /**
168 * @tc.name: ProcessFrameTest008
169 * @tc.desc: test get frame pc
170 * @tc.type: FUNC
171 */
172 HWTEST_F (ProcessFramesTest, ProcessFrameTest008, TestSize.Level2)
173 {
174 GTEST_LOG_(INFO) << "ProcessFrameTest008: start.";
175 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
176 uint64_t pc = 164;
177 frames->SetFramePc(pc);
178 uint64_t framePc = frames->GetFramePc();
179 EXPECT_EQ(true, pc == framePc) << "ProcessFrameTest008 Failed";
180 GTEST_LOG_(INFO) << "ProcessFrameTest008: end.";
181 }
182
183 /**
184 * @tc.name: ProcessFrameTest009
185 * @tc.desc: test get frame pc
186 * @tc.type: FUNC
187 */
188 HWTEST_F (ProcessFramesTest, ProcessFrameTest009, TestSize.Level2)
189 {
190 GTEST_LOG_(INFO) << "ProcessFrameTest009: start.";
191 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
192 uint64_t pc = -1;
193 frames->SetFramePc(pc);
194 uint64_t framePc = frames->GetFramePc();
195 EXPECT_EQ(true, pc == framePc) << "ProcessFrameTest009 Failed";
196 GTEST_LOG_(INFO) << "ProcessFrameTest009: end.";
197 }
198
199 /**
200 * @tc.name: ProcessFrameTest010
201 * @tc.desc: test get frame sp
202 * @tc.type: FUNC
203 */
204 HWTEST_F (ProcessFramesTest, ProcessFrameTest010, TestSize.Level2)
205 {
206 GTEST_LOG_(INFO) << "ProcessFrameTest010: start.";
207 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
208 uint64_t sp = 1;
209 frames->SetFrameSp(sp);
210 uint64_t frameSp = frames->GetFrameSp();
211 EXPECT_EQ(true, sp == frameSp) << "ProcessFrameTest010 Failed";
212 GTEST_LOG_(INFO) << "ProcessFrameTest010: end.";
213 }
214
215 /**
216 * @tc.name: ProcessFrameTest011
217 * @tc.desc: test get frame sp
218 * @tc.type: FUNC
219 */
220 HWTEST_F (ProcessFramesTest, ProcessFrameTest011, TestSize.Level2)
221 {
222 GTEST_LOG_(INFO) << "ProcessFrameTest011: start.";
223 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
224 uint64_t sp = 164;
225 uint64_t frameSp = 0;
226 if (frames != nullptr) {
227 frames->SetFrameSp(sp);
228 frameSp = frames->GetFrameSp();
229 }
230 EXPECT_EQ(true, sp == frameSp) << "ProcessFrameTest011 Failed";
231 GTEST_LOG_(INFO) << "ProcessFrameTest011: end.";
232 }
233
234 /**
235 * @tc.name: ProcessFrameTest012
236 * @tc.desc: test get frame sp
237 * @tc.type: FUNC
238 */
239 HWTEST_F (ProcessFramesTest, ProcessFrameTest012, TestSize.Level2)
240 {
241 GTEST_LOG_(INFO) << "ProcessFrameTest012: start.";
242 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
243 uint64_t sp = -1;
244 frames->SetFrameSp(sp);
245 uint64_t frameSp = frames->GetFrameSp();
246 EXPECT_EQ(true, sp == frameSp) << "ProcessFrameTest012 Failed";
247 GTEST_LOG_(INFO) << "ProcessFrameTest012: end.";
248 }
249
250 /**
251 * @tc.name: ProcessFrameTest013
252 * @tc.desc: test get frame relative pc
253 * @tc.type: FUNC
254 */
255 HWTEST_F (ProcessFramesTest, ProcessFrameTest013, TestSize.Level2)
256 {
257 GTEST_LOG_(INFO) << "ProcessFrameTest013: start.";
258 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
259 uint64_t relativePc = 1;
260 uint64_t frameRelativePc = 0;
261 if (frames != nullptr) {
262 frames->SetFrameRelativePc(relativePc);
263 frameRelativePc = frames->GetFrameRelativePc();
264 }
265 EXPECT_EQ(true, relativePc == frameRelativePc) << "ProcessFrameTest013 Failed";
266 GTEST_LOG_(INFO) << "ProcessFrameTest013: end.";
267 }
268
269 /**
270 * @tc.name: ProcessFrameTest014
271 * @tc.desc: test get frame relative pc
272 * @tc.type: FUNC
273 */
274 HWTEST_F (ProcessFramesTest, ProcessFrameTest014, TestSize.Level2)
275 {
276 GTEST_LOG_(INFO) << "ProcessFrameTest014: start.";
277 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
278 uint64_t relativePc = 164;
279 frames->SetFrameRelativePc(relativePc);
280 uint64_t frameRelativePc = frames->GetFrameRelativePc();
281 EXPECT_EQ(true, relativePc == frameRelativePc) << "ProcessFrameTest014 Failed";
282 GTEST_LOG_(INFO) << "ProcessFrameTest014: end.";
283 }
284
285 /**
286 * @tc.name: ProcessFrameTest015
287 * @tc.desc: test get frame relative pc
288 * @tc.type: FUNC
289 */
290 HWTEST_F (ProcessFramesTest, ProcessFrameTest015, TestSize.Level2)
291 {
292 GTEST_LOG_(INFO) << "ProcessFrameTest015: start.";
293 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
294 uint64_t relativePc = -1;
295 frames->SetFrameRelativePc(relativePc);
296 uint64_t frameRelativePc = frames->GetFrameRelativePc();
297 EXPECT_EQ(true, relativePc == frameRelativePc) << "ProcessFrameTest015 Failed";
298 GTEST_LOG_(INFO) << "ProcessFrameTest015: end.";
299 }
300
301 /**
302 * @tc.name: ProcessFrameTest016
303 * @tc.desc: test get frame func name
304 * @tc.type: FUNC
305 */
306 HWTEST_F (ProcessFramesTest, ProcessFrameTest016, TestSize.Level2)
307 {
308 GTEST_LOG_(INFO) << "ProcessFrameTest016: start.";
309 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
310 std::string name = "zhangsan";
311 std::string frameName = "";
312 if (frames != nullptr) {
313 frames->SetFrameFuncName(name);
314 frameName = frames->GetFrameFuncName();
315 }
316 EXPECT_EQ(true, name == frameName) << "ProcessFrameTest016 Failed";
317 GTEST_LOG_(INFO) << "ProcessFrameTest016: end.";
318 }
319
320 /**
321 * @tc.name: ProcessFrameTest017
322 * @tc.desc: test get frame func name
323 * @tc.type: FUNC
324 */
325 HWTEST_F (ProcessFramesTest, ProcessFrameTest017, TestSize.Level2)
326 {
327 GTEST_LOG_(INFO) << "ProcessFrameTest017: start.";
328 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
329 std::string name = "lisi";
330 std::string frameName = "";
331 if (frames != nullptr) {
332 frames->SetFrameFuncName(name);
333 frameName = frames->GetFrameFuncName();
334 }
335 EXPECT_EQ(true, name == frameName) << "ProcessFrameTest017 Failed";
336 GTEST_LOG_(INFO) << "ProcessFrameTest017: end.";
337 }
338
339 /**
340 * @tc.name: ProcessFrameTest018
341 * @tc.desc: test get frame func name
342 * @tc.type: FUNC
343 */
344 HWTEST_F (ProcessFramesTest, ProcessFrameTest018, TestSize.Level2)
345 {
346 GTEST_LOG_(INFO) << "ProcessFrameTest018: start.";
347 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
348 std::string name = "wangwu";
349 frames->SetFrameFuncName(name);
350 std::string frameName = frames->GetFrameFuncName();
351 EXPECT_EQ(true, name == frameName) << "ProcessFrameTest018 Failed";
352 GTEST_LOG_(INFO) << "ProcessFrameTest018: end.";
353 }
354
355 /**
356 * @tc.name: ProcessFrameTest019
357 * @tc.desc: test get frame func name
358 * @tc.type: FUNC
359 */
360 HWTEST_F (ProcessFramesTest, ProcessFrameTest019, TestSize.Level2)
361 {
362 GTEST_LOG_(INFO) << "ProcessFrameTest019: start.";
363 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
364 std::string name = "maliu";
365 frames->SetFrameFuncName(name);
366 std::string frameName = frames->GetFrameFuncName();
367 EXPECT_EQ(true, name == frameName) << "ProcessFrameTest019 Failed";
368 GTEST_LOG_(INFO) << "ProcessFrameTest019: end.";
369 }
370
371 /**
372 * @tc.name: ProcessFrameTest020
373 * @tc.desc: test get frame func name
374 * @tc.type: FUNC
375 */
376 HWTEST_F (ProcessFramesTest, ProcessFrameTest020, TestSize.Level2)
377 {
378 GTEST_LOG_(INFO) << "ProcessFrameTest020: start.";
379 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
380 std::string name = "liuqi";
381 std::string frameName = " ";
382 if (frames != nullptr) {
383 frames->SetFrameFuncName(name);
384 frameName = frames->GetFrameFuncName();
385 }
386 EXPECT_EQ(true, name == frameName) << "ProcessFrameTest020 Failed";
387 GTEST_LOG_(INFO) << "ProcessFrameTest020: end.";
388 }
389
390 /**
391 * @tc.name: ProcessFrameTest021
392 * @tc.desc: test get frame func name
393 * @tc.type: FUNC
394 */
395 HWTEST_F (ProcessFramesTest, ProcessFrameTest021, TestSize.Level2)
396 {
397 GTEST_LOG_(INFO) << "ProcessFrameTest021: start.";
398 std::shared_ptr<DfxFrame> frames = std::make_shared<DfxFrame>();
399 std::string name = "";
400 frames->SetFrameFuncName(name);
401 std::string frameName = frames->GetFrameFuncName();
402 EXPECT_EQ(true, name == frameName) << "ProcessFrameTest021 Failed";
403 GTEST_LOG_(INFO) << "ProcessFrameTest021: end.";
404 }
405 }
406