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