1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
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 "hook_record_factory_test.h"
17 #include "native_hook_config.pb.h"
18 #include <string>
19 #include <sys/time.h>
20 #include <vector>
21
22 using namespace testing::ext;
23 using namespace std;
24
25 namespace OHOS::Developtools::NativeDaemon {
26 NativeHookConfig g_hookConfig;
27 std::shared_ptr<HookRecordFactory> g_factory = nullptr;
28 class HookRecordFactoryTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase(void)36 void HookRecordFactoryTest::SetUpTestCase(void) {}
TearDownTestCase(void)37 void HookRecordFactoryTest::TearDownTestCase(void) {}
SetUp()38 void HookRecordFactoryTest::SetUp()
39 {
40 g_factory = std::make_shared<HookRecordFactory>(g_hookConfig);
41 }
TearDown()42 void HookRecordFactoryTest::TearDown()
43 {
44 g_factory = nullptr;
45 }
46
47 /*
48 * @tc.name: GetFreeSimpRecord
49 * @tc.desc: test HookRecordFactory::GetHookRecord with free simple message.
50 * @tc.type: FUNC
51 */
52 HWTEST_F(HookRecordFactoryTest, GetFreeSimpRecord, TestSize.Level1)
53 {
54 int8_t addr = 1;
55 int8_t data[] = {addr};
56 uint32_t dataSize = sizeof(void *);
57 std::shared_ptr<HookRecord> hookRecord = g_factory->GetHookRecord(data, dataSize);
58 EXPECT_EQ(hookRecord->GetType(), FREE_MSG_SIMP);
59 }
60
61 /*
62 * @tc.name: GetJsRecord
63 * @tc.desc: test HookRecordFactory::GetHookRecord with js message.
64 * @tc.type: FUNC
65 */
66 HWTEST_F(HookRecordFactoryTest, GetJsRecord, TestSize.Level1)
67 {
68 StackRawData rawdata;
69 rawdata.type = JS_STACK_MSG;
70 uint32_t dataSize = sizeof(StackRawData);
71 int8_t* data = new int8_t[sizeof(StackRawData)];
72 if (memcpy_s(data, sizeof(StackRawData), &rawdata, sizeof(StackRawData)) == EOK) {
73 std::shared_ptr<HookRecord> hookRecord = g_factory->GetHookRecord(data, dataSize);
74 EXPECT_EQ(hookRecord->GetType(), JS_STACK_MSG);
75 }
76 delete[] data;
77 }
78
79 /*
80 * @tc.name: GetMallocRecord
81 * @tc.desc: test HookRecordFactory::GetHookRecord with malloc message.
82 * @tc.type: FUNC
83 */
84 HWTEST_F(HookRecordFactoryTest, GetMallocRecord, TestSize.Level1)
85 {
86 StackRawData rawdata;
87 rawdata.type = MALLOC_MSG;
88 uint32_t dataSize = sizeof(StackRawData);
89 int8_t* data = new int8_t[sizeof(StackRawData)];
90 if (memcpy_s(data, sizeof(StackRawData), &rawdata, sizeof(StackRawData)) == EOK) {
91 std::shared_ptr<HookRecord> hookRecord = g_factory->GetHookRecord(data, dataSize);
92 EXPECT_EQ(hookRecord->GetType(), MALLOC_MSG);
93 }
94 delete[] data;
95 }
96
97 /*
98 * @tc.name: GetNmdRecord
99 * @tc.desc: test HookRecordFactory::GetHookRecord with jemalloc stats message.
100 * @tc.type: FUNC
101 */
102 HWTEST_F(HookRecordFactoryTest, GetNmdRecord, TestSize.Level1)
103 {
104 StackRawData rawdata;
105 rawdata.type = NMD_MSG;
106 uint32_t dataSize = sizeof(StackRawData);
107 int8_t* data = new int8_t[sizeof(StackRawData)];
108 if (memcpy_s(data, sizeof(StackRawData), &rawdata, sizeof(StackRawData)) == EOK) {
109 std::shared_ptr<HookRecord> hookRecord = g_factory->GetHookRecord(data, dataSize);
110 EXPECT_EQ(hookRecord->GetType(), NMD_MSG);
111 }
112 delete[] data;
113 }
114
115 /*
116 * @tc.name: GetFreeRecord
117 * @tc.desc: test HookRecordFactory::GetHookRecord with free message.
118 * @tc.type: FUNC
119 */
120 HWTEST_F(HookRecordFactoryTest, GetFreeRecord, TestSize.Level1)
121 {
122 StackRawData rawdata;
123 rawdata.type = FREE_MSG;
124 uint32_t dataSize = sizeof(StackRawData);
125 int8_t* data = new int8_t[sizeof(StackRawData)];
126 if (memcpy_s(data, sizeof(StackRawData), &rawdata, sizeof(StackRawData)) == EOK) {
127 std::shared_ptr<HookRecord> hookRecord = g_factory->GetHookRecord(data, dataSize);
128 EXPECT_EQ(hookRecord->GetType(), FREE_MSG);
129 }
130 delete[] data;
131 }
132
133 /*
134 * @tc.name: ReturnMallocRecord
135 * @tc.desc: test HookRecordFactory::SaveHookRecord with malloc message.
136 * @tc.type: FUNC
137 */
138 HWTEST_F(HookRecordFactoryTest, ReturnMallocRecord, TestSize.Level1)
139 {
140 StackRawData rawdata;
141 rawdata.type = MALLOC_MSG;
142 uint32_t dataSize = sizeof(StackRawData);
143 int8_t* data = new int8_t[sizeof(StackRawData)];
144 if (memcpy_s(data, sizeof(StackRawData), &rawdata, sizeof(StackRawData)) == EOK) {
145 std::shared_ptr<HookRecord> hookRecord = g_factory->GetHookRecord(data, dataSize);
146 EXPECT_EQ(g_factory->mallocRecordCache_.size(), HOOK_RECORD_CACHE_INIT_SIZE - 1);
147 g_factory->SaveHookRecord(hookRecord);
148 EXPECT_EQ(g_factory->mallocRecordCache_.size(), HOOK_RECORD_CACHE_INIT_SIZE);
149 }
150 delete[] data;
151 }
152
153 /*
154 * @tc.name: ReturnMmapRecord
155 * @tc.desc: test HookRecordFactory::SaveHookRecord with mmap message.
156 * @tc.type: FUNC
157 */
158 HWTEST_F(HookRecordFactoryTest, ReturnMmapRecord, TestSize.Level1)
159 {
160 StackRawData rawdata;
161 rawdata.type = MMAP_MSG;
162 uint32_t dataSize = sizeof(StackRawData);
163 int8_t* data = new int8_t[sizeof(StackRawData)];
164 if (memcpy_s(data, sizeof(StackRawData), &rawdata, sizeof(StackRawData)) == EOK) {
165 std::shared_ptr<HookRecord> hookRecord = g_factory->GetHookRecord(data, dataSize);
166 EXPECT_EQ(g_factory->mmapRecordCache_.size(), HOOK_RECORD_CACHE_INIT_SIZE - 1);
167 g_factory->SaveHookRecord(hookRecord);
168 EXPECT_EQ(g_factory->mmapRecordCache_.size(), HOOK_RECORD_CACHE_INIT_SIZE);
169 }
170 delete[] data;
171 }
172
173 /*
174 * @tc.name: ReturnEndRecord
175 * @tc.desc: test HookRecordFactory::SaveHookRecord with end message.
176 * @tc.type: FUNC
177 */
178 HWTEST_F(HookRecordFactoryTest, ReturnEndRecord, TestSize.Level1)
179 {
180 StackRawData rawdata;
181 rawdata.type = END_MSG;
182 uint32_t dataSize = sizeof(StackRawData);
183 int8_t* data = new int8_t[sizeof(StackRawData)];
184 if (memcpy_s(data, sizeof(StackRawData), &rawdata, sizeof(StackRawData)) == EOK) {
185 std::shared_ptr<HookRecord> hookRecord = g_factory->GetHookRecord(data, dataSize);
186 EXPECT_EQ(g_factory->mallocRecordCache_.size(), HOOK_RECORD_CACHE_INIT_SIZE);
187 EXPECT_EQ(g_factory->mmapRecordCache_.size(), HOOK_RECORD_CACHE_INIT_SIZE);
188 g_factory->SaveHookRecord(hookRecord);
189 EXPECT_EQ(g_factory->mallocRecordCache_.size(), HOOK_RECORD_CACHE_INIT_SIZE);
190 EXPECT_EQ(g_factory->mmapRecordCache_.size(), HOOK_RECORD_CACHE_INIT_SIZE);
191 }
192 delete[] data;
193 }
194 }