1 /*
2 * Copyright (c) 2025 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 #include <gtest/gtest.h>
16 #include <gmock/gmock.h>
17 #include <dlfcn.h>
18
19 #include "gmock/gmock.h"
20 #include "grd_adapter_manager.h"
21 #include "grd_adapter.h"
22 #include "gdb_store.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::DistributedDataAip;
26 using ::testing::Return;
27 using ::testing::NiceMock;
28 class MockDlsym {
29 public:
30 MOCK_METHOD(void *, dlopen, (const char *fileName, int flag));
31 MOCK_METHOD(void *, dlsym, (void *handle, const char *symbol));
32 };
33
34 NiceMock<MockDlsym> *mockDlsym;
35
36 extern "C" {
37 // mock dlopen
dlopen(const char * fileName,int flag)38 void *dlopen(const char *fileName, int flag)
39 {
40 if (mockDlsym == nullptr) {
41 mockDlsym = new NiceMock<MockDlsym>();
42 }
43 return mockDlsym->dlopen(fileName, flag);
44 }
45
46 // mock dlsym
dlsym(void * handle,const char * symbol)47 void *dlsym(void *handle, const char *symbol)
48 {
49 if (mockDlsym == nullptr) {
50 mockDlsym = new NiceMock<MockDlsym>();
51 }
52 return mockDlsym->dlsym(handle, symbol);
53 }
54 }
55
56 class GdbAdaptTest : public testing::Test {
57 public:
58 static void SetUpTestCase(void);
59 static void TearDownTestCase(void);
60 void SetUp();
61 void TearDown();
62 void MockAllSymbols();
63 static const std::string databaseName;
64 static const std::string databasePath;
65 const std::vector<std::pair<std::string, void *>> mockSymbols = {
66 {"GRD_DBOpen", reinterpret_cast<void *>(0x1111)},
67 {"GRD_DBClose", reinterpret_cast<void *>(0x2222)},
68 {"GRD_DBRepair", reinterpret_cast<void *>(0x3333)},
69 {"GRD_GqlPrepare", reinterpret_cast<void *>(0x4444)},
70 {"GRD_GqlReset", reinterpret_cast<void *>(0x5555)},
71 {"GRD_GqlFinalize", reinterpret_cast<void *>(0x6666)},
72 {"GRD_GqlStep", reinterpret_cast<void *>(0x7777)},
73 {"GRD_GqlColumnCount", reinterpret_cast<void *>(0x8888)},
74 {"GRD_GqlColumnType", reinterpret_cast<void *>(0x9999)},
75 {"GRD_GqlColumnBytes", reinterpret_cast<void *>(0xaaaa)},
76 {"GRD_GqlColumnName", reinterpret_cast<void *>(0xbbbb)},
77 {"GRD_GqlColumnValue", reinterpret_cast<void *>(0xcccc)},
78 {"GRD_GqlColumnInt64", reinterpret_cast<void *>(0xdddd)},
79 {"GRD_GqlColumnInt", reinterpret_cast<void *>(0xeeee)},
80 {"GRD_GqlColumnDouble", reinterpret_cast<void *>(0xffff)},
81 {"GRD_GqlColumnText", reinterpret_cast<void *>(0x1112)},
82 {"GRD_DBBackup", reinterpret_cast<void *>(0x1222)},
83 {"GRD_DBRestore", reinterpret_cast<void *>(0x1333)},
84 {"GRD_DBRekey", reinterpret_cast<void *>(0x1444)},
85 };
86 };
87
88 const std::string GdbAdaptTest::databaseName = "execute_test";
89 const std::string GdbAdaptTest::databasePath = "/data";
90
SetUpTestCase(void)91 void GdbAdaptTest::SetUpTestCase(void)
92 {
93 if (!IsSupportArkDataDb()) {
94 GTEST_SKIP() << "Current testcase is not compatible from current gdb";
95 return;
96 }
97 mockDlsym = new NiceMock<MockDlsym>();
98 }
99
TearDownTestCase(void)100 void GdbAdaptTest::TearDownTestCase(void)
101 {
102 delete mockDlsym;
103 mockDlsym = nullptr;
104 }
105
SetUp()106 void GdbAdaptTest::SetUp()
107 {
108 if (!IsSupportArkDataDb()) {
109 GTEST_SKIP() << "Current testcase is not compatible from current gdb";
110 return;
111 }
112 }
113
TearDown()114 void GdbAdaptTest::TearDown()
115 {
116 }
117
MockAllSymbols()118 void GdbAdaptTest::MockAllSymbols()
119 {
120 EXPECT_CALL(*mockDlsym, dlopen(::testing::_, RTLD_LAZY))
121 .WillRepeatedly(Return(reinterpret_cast<void *>(0x1234)));
122
123 for (const auto &symbol : mockSymbols) {
124 EXPECT_CALL(*mockDlsym, dlsym(::testing::_, ::testing::StrEq(symbol.first.c_str())))
125 .WillRepeatedly(Return(symbol.second));
126 }
127 }
128
129 /**
130 * @tc.name: GdbAdaptTest_Dlopen01
131 * @tc.desc: No Mock All Symbols
132 * @tc.type: FUNC
133 */
134 HWTEST_F(GdbAdaptTest, GdbAdaptTest_Dlopen01, TestSize.Level2)
135 {
136 GetAdapterHolder();
137 EXPECT_CALL(*mockDlsym, dlopen(::testing::_, RTLD_LAZY))
138 .WillRepeatedly(Return(reinterpret_cast<void *>(0x1234)));
139 GrdAdapterHolder holder = GetAdapterHolder();
140 EXPECT_EQ(holder.Open, nullptr);
141 EXPECT_EQ(holder.Close, nullptr);
142 EXPECT_EQ(holder.Repair, nullptr);
143 EXPECT_EQ(holder.Prepare, nullptr);
144 EXPECT_EQ(holder.Reset, nullptr);
145 EXPECT_EQ(holder.Finalize, nullptr);
146 EXPECT_EQ(holder.Step, nullptr);
147 EXPECT_EQ(holder.ColumnCount, nullptr);
148 EXPECT_EQ(holder.GetColumnType, nullptr);
149 EXPECT_EQ(holder.ColumnBytes, nullptr);
150 EXPECT_EQ(holder.ColumnName, nullptr);
151 EXPECT_EQ(holder.ColumnValue, nullptr);
152 EXPECT_EQ(holder.ColumnInt64, nullptr);
153 EXPECT_EQ(holder.ColumnInt, nullptr);
154 EXPECT_EQ(holder.ColumnDouble, nullptr);
155 EXPECT_EQ(holder.ColumnText, nullptr);
156 EXPECT_EQ(holder.Backup, nullptr);
157 EXPECT_EQ(holder.Restore, nullptr);
158 EXPECT_EQ(holder.Rekey, nullptr);
159 GrdAdapter::Open(databaseName.c_str(), databasePath.c_str(), 1, nullptr);
160 GrdAdapter::Close(nullptr, 1);
161 GrdAdapter::Repair(databasePath.c_str(), {});
162 GrdAdapter::Prepare(nullptr, databaseName.c_str(), 1, nullptr, nullptr);
163 GrdAdapter::Reset(nullptr);
164 GrdAdapter::Finalize(nullptr);
165 GrdAdapter::Step(nullptr);
166 GrdAdapter::ColumnCount(nullptr);
167 GrdAdapter::ColumnType(nullptr, 1);
168 GrdAdapter::ColumnBytes(nullptr, 1);
169 GrdAdapter::ColumnName(nullptr, 1);
170 GrdAdapter::ColumnValue(nullptr, 1);
171 GrdAdapter::ColumnInt64(nullptr, 1);
172 GrdAdapter::ColumnInt(nullptr, 1);
173 GrdAdapter::ColumnDouble(nullptr, 1);
174 GrdAdapter::ColumnText(nullptr, 1);
175 GrdAdapter::Backup(nullptr, databaseName.c_str(), {});
176 GrdAdapter::Restore(nullptr, databaseName.c_str(), {});
177 GrdAdapter::Rekey(nullptr, databaseName.c_str(), {});
178 }
179
180 /**
181 * @tc.name: GdbAdaptTest_Dlopen02
182 * @tc.desc: Mock All Symbols test.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(GdbAdaptTest, GdbAdaptTest_Dlopen02, TestSize.Level2)
186 {
187 EXPECT_CALL(*mockDlsym, dlopen(::testing::_, RTLD_LAZY))
188 .WillRepeatedly(Return(reinterpret_cast<void *>(0x1234)));
189 MockAllSymbols();
190 GrdAdapterHolder holder = GetAdapterHolder();
191 EXPECT_NE(holder.Open, nullptr);
192 EXPECT_NE(holder.Close, nullptr);
193 EXPECT_NE(holder.Repair, nullptr);
194 EXPECT_NE(holder.Prepare, nullptr);
195 EXPECT_NE(holder.Reset, nullptr);
196 EXPECT_NE(holder.Finalize, nullptr);
197 EXPECT_NE(holder.Step, nullptr);
198 EXPECT_NE(holder.ColumnCount, nullptr);
199 EXPECT_NE(holder.GetColumnType, nullptr);
200 EXPECT_NE(holder.ColumnBytes, nullptr);
201 EXPECT_NE(holder.ColumnName, nullptr);
202 EXPECT_NE(holder.ColumnValue, nullptr);
203 EXPECT_NE(holder.ColumnInt64, nullptr);
204 EXPECT_NE(holder.ColumnInt, nullptr);
205 EXPECT_NE(holder.ColumnDouble, nullptr);
206 EXPECT_NE(holder.ColumnText, nullptr);
207 EXPECT_NE(holder.Backup, nullptr);
208 EXPECT_NE(holder.Restore, nullptr);
209 EXPECT_NE(holder.Rekey, nullptr);
210 }