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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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