1 /*
2 * Copyright (c) 2024 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 #include <gtest/gtest.h>
17 #include <memory>
18 #include <sys/types.h>
19
20 #include "unique_stack_table.h"
21
22 using namespace OHOS::HiviewDFX;
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace HiviewDFX {
28 namespace {
29 static const int BUF_LEN = 100;
30 }
31
32 class StackTableTest : public testing::Test {
33 public:
SetUpTestCase(void)34 static void SetUpTestCase(void) {}
TearDownTestCase(void)35 static void TearDownTestCase(void) {}
SetUp()36 void SetUp() {}
TearDown()37 void TearDown() {}
38 };
39
40 namespace {
41 /**
42 * @tc.name: StackTableTest001
43 * @tc.desc: test StackTable functions
44 * @tc.type: FUNC
45 */
HWTEST_F(StackTableTest, StackTableTest001, TestSize.Level2)46 HWTEST_F(StackTableTest, StackTableTest001, TestSize.Level2)
47 {
48 GTEST_LOG_(INFO) << "StackTableTest001: start.";
49 Node node;
50 node.value = 1;
51 char buf[BUF_LEN] = "6fd1bf000-6fd2bf000 rw-p 00000000 b3:07 1882 [anon:async_stack_table]";
52 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(buf, sizeof(buf));
53 ASSERT_EQ(stackTable->ImportNode(0, node), true);
54 ASSERT_EQ(stackTable->GetHeadNode()->value, node.value);
55 size_t functionsSize = stackTable->GetWriteSize();
56 uint32_t oldSize = stackTable->GetTabelSize();
57 uint32_t usedNodes = stackTable->GetUsedIndexes().size();
58 auto pid = stackTable->GetPid();
59 size_t resultSize = sizeof(pid) + sizeof(stackTable->GetTabelSize());
60 size_t usedNodesSize = sizeof(usedNodes) + usedNodes * sizeof(uint32_t) + usedNodes * sizeof(uint64_t);
61 ASSERT_EQ(usedNodesSize + resultSize, functionsSize);
62 ASSERT_EQ(stackTable->Resize(), true);
63 ASSERT_NE(stackTable->GetTabelSize(), oldSize);
64 GTEST_LOG_(INFO) << "StackTableTest001: end.";
65 }
66
67 /**
68 * @tc.name: StackTableTest002
69 * @tc.desc: test StackTable functions
70 * @tc.type: FUNC
71 */
HWTEST_F(StackTableTest, StackTableTest002, TestSize.Level2)72 HWTEST_F(StackTableTest, StackTableTest002, TestSize.Level2)
73 {
74 GTEST_LOG_(INFO) << "StackTableTest002: start.";
75 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(nullptr,
76 MAX_NODES_CNT * MAX_NODES_CNT);
77 bool ret = stackTable->Init();
78 ASSERT_EQ(ret, false);
79 ret = stackTable->Resize();
80 ASSERT_EQ(ret, false);
81 GTEST_LOG_(INFO) << "StackTableTest002: end.";
82 }
83
84 /**
85 * @tc.name: StackTableTest003
86 * @tc.desc: test StackTable functions
87 * @tc.type: FUNC
88 */
HWTEST_F(StackTableTest, StackTableTest003, TestSize.Level2)89 HWTEST_F(StackTableTest, StackTableTest003, TestSize.Level2)
90 {
91 GTEST_LOG_(INFO) << "StackTableTest003: start.";
92 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(nullptr, 0);
93 bool ret = stackTable->Init();
94 ASSERT_EQ(ret, false);
95 ret = stackTable->Resize();
96 ASSERT_EQ(ret, false);
97 GTEST_LOG_(INFO) << "StackTableTest003: end.";
98 }
99
100 /**
101 * @tc.name: StackTableTest004
102 * @tc.desc: test StackTable functions
103 * @tc.type: FUNC
104 */
HWTEST_F(StackTableTest, StackTableTest004, TestSize.Level2)105 HWTEST_F(StackTableTest, StackTableTest004, TestSize.Level2)
106 {
107 GTEST_LOG_(INFO) << "StackTableTest004: start.";
108 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(nullptr,
109 MAX_NODES_CNT * MAX_NODES_CNT);
110 uint64_t ret = stackTable->PutPcsInTable(nullptr, nullptr, 0);
111 ASSERT_EQ(ret, 0);
112 GTEST_LOG_(INFO) << "StackTableTest004: end.";
113 }
114
115 /**
116 * @tc.name: StackTableTest005
117 * @tc.desc: test StackTable functions
118 * @tc.type: FUNC
119 */
HWTEST_F(StackTableTest, StackTableTest005, TestSize.Level2)120 HWTEST_F(StackTableTest, StackTableTest005, TestSize.Level2)
121 {
122 GTEST_LOG_(INFO) << "StackTableTest005: start.";
123 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(nullptr,
124 MAX_NODES_CNT * MAX_NODES_CNT);
125 size_t ret = stackTable->GetWriteSize();
126 ASSERT_EQ(ret, 0);
127 GTEST_LOG_(INFO) << "StackTableTest005: end.";
128 }
129
130 /**
131 * @tc.name: StackTableTest006
132 * @tc.desc: test StackTable functions
133 * @tc.type: FUNC
134 */
HWTEST_F(StackTableTest, StackTableTest006, TestSize.Level2)135 HWTEST_F(StackTableTest, StackTableTest006, TestSize.Level2)
136 {
137 GTEST_LOG_(INFO) << "StackTableTest006: start.";
138 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(nullptr, 0);
139 StackId stackId;
140 std::vector<uintptr_t> pcs;
141 bool ret = stackTable->GetPcsByStackId(stackId, pcs);
142 ASSERT_EQ(ret, false);
143 GTEST_LOG_(INFO) << "StackTableTest006: end.";
144 }
145
146 /**
147 * @tc.name: StackTableTest007
148 * @tc.desc: test StackTable functions
149 * @tc.type: FUNC
150 */
HWTEST_F(StackTableTest, StackTableTest007, TestSize.Level2)151 HWTEST_F(StackTableTest, StackTableTest007, TestSize.Level2)
152 {
153 GTEST_LOG_(INFO) << "StackTableTest007: start.";
154 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(0, 0);
155 Node node;
156 bool ret = stackTable->ImportNode(MAX_NODES_CNT, node);
157 ASSERT_EQ(ret, false);
158 GTEST_LOG_(INFO) << "StackTableTest007: end.";
159 }
160
161 /**
162 * @tc.name: StackTableTest008
163 * @tc.desc: test StackTable functions
164 * @tc.type: FUNC
165 */
HWTEST_F(StackTableTest, StackTableTest008, TestSize.Level2)166 HWTEST_F(StackTableTest, StackTableTest008, TestSize.Level2)
167 {
168 GTEST_LOG_(INFO) << "StackTableTest008: start.";
169 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(0, 0);
170 uint64_t ret = stackTable->PutPcInSlot(0, 0);
171 ASSERT_EQ(ret, 0);
172 GTEST_LOG_(INFO) << "StackTableTest008: end.";
173 }
174
175 /**
176 * @tc.name: StackTableTest009
177 * @tc.desc: test StackTable functions
178 * @tc.type: FUNC
179 */
HWTEST_F(StackTableTest, StackTableTest009, TestSize.Level2)180 HWTEST_F(StackTableTest, StackTableTest009, TestSize.Level2)
181 {
182 GTEST_LOG_(INFO) << "StackTableTest009: start.";
183 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(0, 0);
184 Node* ret = stackTable->GetFrame(MAX_NODES_CNT);
185 ASSERT_EQ(ret, nullptr);
186 GTEST_LOG_(INFO) << "StackTableTest009: end.";
187 }
188
189
190 /**
191 * @tc.name: StackTableTest010
192 * @tc.desc: test StackTable functions
193 * @tc.type: FUNC
194 */
HWTEST_F(StackTableTest, StackTableTest010, TestSize.Level2)195 HWTEST_F(StackTableTest, StackTableTest010, TestSize.Level2)
196 {
197 GTEST_LOG_(INFO) << "StackTableTest010: start.";
198 const size_t size = (MAX_NODES_CNT + 10) * sizeof(Node);
199 std::shared_ptr<UniqueStackTable> stackTable = make_shared<UniqueStackTable>(nullptr,
200 size);
201 bool ret = stackTable->Init();
202 ASSERT_EQ(ret, false);
203 GTEST_LOG_(INFO) << "StackTableTest010: end.";
204 }
205 }
206 } // namespace HiviewDFX
207 } // namespace OHOS