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 #include "shared_block.h"
16
17 #include <gtest/gtest.h>
18
19 #include <cstdint>
20 #include <memory>
21 #include <string>
22
23 #include "ashmem.h"
24 #include "datashare_log.h"
25 #include "refbase.h"
26
27 namespace OHOS {
28 namespace DataShare {
29 using namespace testing::ext;
30 using namespace OHOS::AppDataFwk;
31
32 class SharedBlockTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void SharedBlockTest::SetUpTestCase(void)
41 {
42 }
TearDownTestCase(void)43 void SharedBlockTest::TearDownTestCase(void)
44 {
45 }
SetUp(void)46 void SharedBlockTest::SetUp(void)
47 {
48 }
TearDown(void)49 void SharedBlockTest::TearDown(void)
50 {
51 }
52
53 HWTEST_F(SharedBlockTest, InitTest001, TestSize.Level0)
54 {
55 LOG_INFO("InitTest001::Start");
56 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("ahsmem", sizeof(SharedBlock::SharedBlockHeader));
57 EXPECT_NE(ashmem, nullptr);
58 ashmem->startAddr_ = nullptr;
59 SharedBlock *sharedBlock = new SharedBlock("name", ashmem, 0, true);
60 EXPECT_EQ(sharedBlock->Init(), false);
61 LOG_INFO("InitTest001::End");
62 }
63
64 HWTEST_F(SharedBlockTest, CreateSharedBlockTest001, TestSize.Level0)
65 {
66 LOG_INFO("CreateSharedBlockTest001::Start");
67 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("ahsmem", sizeof(SharedBlock::SharedBlockHeader));
68 EXPECT_NE(ashmem, nullptr);
69 ashmem->startAddr_ = nullptr;
70 AppDataFwk::SharedBlock *sharedBlock = nullptr;
71 EXPECT_EQ(sharedBlock->CreateSharedBlock("name", sizeof(SharedBlock::SharedBlockHeader), ashmem, sharedBlock),
72 SharedBlock::SHARED_BLOCK_ASHMEM_ERROR);
73 LOG_INFO("CreateSharedBlockTest001::End");
74 }
75
76 HWTEST_F(SharedBlockTest, CreateTest001, TestSize.Level0)
77 {
78 LOG_INFO("CreateTest001::Start");
79 AppDataFwk::SharedBlock *sharedBlock = nullptr;
80 EXPECT_EQ(SharedBlock::Create("name", -1, sharedBlock), SharedBlock::SHARED_BLOCK_ASHMEM_ERROR);
81 LOG_INFO("CreateTest001::End");
82 }
83
84 HWTEST_F(SharedBlockTest, ReadMessageParcelTest001, TestSize.Level0)
85 {
86 LOG_INFO("ReadMessageParcelTest001::Start");
87 MessageParcel parcel;
88 std::u16string str = u"string";
89 SharedBlock *block = nullptr;
90 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("ahsmem", sizeof(SharedBlock::SharedBlockHeader));
91 EXPECT_NE(ashmem, nullptr);
92 ashmem->startAddr_ = nullptr;
93 parcel.WriteString16(str);
94 parcel.WriteAshmem(ashmem);
95 EXPECT_EQ(SharedBlock::ReadMessageParcel(parcel, block), SharedBlock::SHARED_BLOCK_OK);
96
97 LOG_INFO("ReadMessageParcelTest001::End");
98 }
99
100 HWTEST_F(SharedBlockTest, ClearTest001, TestSize.Level0)
101 {
102 LOG_INFO("ClearTest001::Start");
103 AppDataFwk::SharedBlock *sharedBlock = nullptr;
104 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
105 SharedBlock::SHARED_BLOCK_OK);
106 EXPECT_NE(sharedBlock, nullptr);
107 sharedBlock->mReadOnly = true;
108 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
109 sharedBlock->mReadOnly = false;
110 sharedBlock->mSize = sizeof(SharedBlock::SharedBlockHeader);
111 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_BAD_VALUE);
112 sharedBlock->mSize = sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader);
113 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
114 LOG_INFO("ClearTest001::End");
115 }
116
117 HWTEST_F(SharedBlockTest, SetColumnNumTest001, TestSize.Level0)
118 {
119 LOG_INFO("SetColumnNumTest001::Start");
120 AppDataFwk::SharedBlock *sharedBlock = nullptr;
121 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
122 SharedBlock::SHARED_BLOCK_OK);
123 EXPECT_NE(sharedBlock, nullptr);
124 sharedBlock->mReadOnly = true;
125 uint32_t numColumns = 1;
126 EXPECT_EQ(sharedBlock->SetColumnNum(numColumns), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
127 sharedBlock->mReadOnly = false;
128 sharedBlock->mHeader->columnNums = numColumns;
129 sharedBlock->mHeader->rowNums = numColumns;
130 EXPECT_EQ(sharedBlock->SetColumnNum(0), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
131 sharedBlock->mHeader->columnNums = 0;
132 sharedBlock->mHeader->rowNums = numColumns;
133 EXPECT_EQ(sharedBlock->SetColumnNum(numColumns), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
134 sharedBlock->mHeader->columnNums = numColumns;
135 sharedBlock->mHeader->rowNums = 0;
136 EXPECT_EQ(sharedBlock->SetColumnNum(0), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
137 numColumns = 32768; // 32768 is max_num
138 sharedBlock->mHeader->columnNums = numColumns;
139 sharedBlock->mHeader->rowNums = numColumns;
140 EXPECT_EQ(sharedBlock->SetColumnNum(numColumns), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
141 numColumns = 1;
142 sharedBlock->mHeader->columnNums = numColumns;
143 sharedBlock->mHeader->rowNums = numColumns;
144 EXPECT_EQ(sharedBlock->SetColumnNum(numColumns), SharedBlock::SHARED_BLOCK_OK);
145 sharedBlock->mHeader->columnNums = 0;
146 sharedBlock->mHeader->rowNums = 0;
147 EXPECT_EQ(sharedBlock->SetColumnNum(0), SharedBlock::SHARED_BLOCK_OK);
148 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
149 LOG_INFO("SetColumnNumTest001::End");
150 }
151
152 HWTEST_F(SharedBlockTest, AllocRow, TestSize.Level0)
153 {
154 LOG_INFO("AllocRowTest001::Start");
155 AppDataFwk::SharedBlock *sharedBlock = nullptr;
156 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
157 SharedBlock::SHARED_BLOCK_OK);
158 EXPECT_NE(sharedBlock, nullptr);
159 sharedBlock->mReadOnly = true;
160 EXPECT_EQ(sharedBlock->AllocRow(), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
161 sharedBlock->mReadOnly = false;
162 sharedBlock->mSize = 0;
163 EXPECT_EQ(sharedBlock->AllocRow(), SharedBlock::SHARED_BLOCK_NO_MEMORY);
164 sharedBlock->mSize = sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader);
165 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
166 LOG_INFO("AllocRowTest001::End");
167 }
168
169 HWTEST_F(SharedBlockTest, FreeLastRowTest001, TestSize.Level0)
170 {
171 LOG_INFO("FreeLastRowTest001::Start");
172 AppDataFwk::SharedBlock *sharedBlock = nullptr;
173 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
174 SharedBlock::SHARED_BLOCK_OK);
175 EXPECT_NE(sharedBlock, nullptr);
176 sharedBlock->mReadOnly = true;
177 EXPECT_EQ(sharedBlock->FreeLastRow(), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
178 sharedBlock->mReadOnly = false;
179 auto temp = sharedBlock->mHeader->rowNums + 1;
180 sharedBlock->mHeader->rowNums = 0;
181 EXPECT_EQ(sharedBlock->FreeLastRow(), SharedBlock::SHARED_BLOCK_OK);
182 sharedBlock->mHeader->rowNums = temp;
183 EXPECT_EQ(sharedBlock->FreeLastRow(), SharedBlock::SHARED_BLOCK_OK);
184 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
185 LOG_INFO("FreeLastRowTest001::End");
186 }
187
188 HWTEST_F(SharedBlockTest, AllocRowOffsetTest001, TestSize.Level0)
189 {
190 LOG_INFO("AllocRowOffsetTest001::Start");
191 AppDataFwk::SharedBlock *sharedBlock = nullptr;
192 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
193 SharedBlock::SHARED_BLOCK_OK);
194 EXPECT_NE(sharedBlock, nullptr);
195 auto temp = sharedBlock->mSize;
196 sharedBlock->mSize = 0;
197 EXPECT_EQ(sharedBlock->AllocRowOffset(), nullptr);
198 sharedBlock->mSize = temp;
199 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
200 LOG_INFO("AllocRowOffsetTest001::End");
201 }
202
203 HWTEST_F(SharedBlockTest, GetCellUnitTest001, TestSize.Level0)
204 {
205 LOG_INFO("GetCellUnitTest001::Start");
206 AppDataFwk::SharedBlock *sharedBlock = nullptr;
207 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
208 SharedBlock::SHARED_BLOCK_OK);
209 EXPECT_NE(sharedBlock, nullptr);
210 auto rowTemp = sharedBlock->mHeader->rowNums;
211 auto culTemp = sharedBlock->mHeader->columnNums;
212 auto sizeTemp = sharedBlock->mSize;
213 sharedBlock->mHeader->rowNums = 1;
214 sharedBlock->mHeader->columnNums = 1;
215 sharedBlock->mSize = 0;
216 EXPECT_EQ(sharedBlock->GetCellUnit(1, 0), nullptr);
217 EXPECT_EQ(sharedBlock->GetCellUnit(0, 1), nullptr);
218 EXPECT_EQ(sharedBlock->GetCellUnit(0, 0), nullptr);
219 sharedBlock->mHeader->rowNums = rowTemp;
220 sharedBlock->mHeader->columnNums = culTemp;
221 sharedBlock->mSize = sizeTemp;
222 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
223 LOG_INFO("GetCellUnitTest001::End");
224 }
225
226 HWTEST_F(SharedBlockTest, PutBlobOrStringTest001, TestSize.Level0)
227 {
228 LOG_INFO("PutBlobOrStringTest001::Start");
229 AppDataFwk::SharedBlock *sharedBlock = nullptr;
230 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
231 SharedBlock::SHARED_BLOCK_OK);
232 EXPECT_NE(sharedBlock, nullptr);
233 sharedBlock->mReadOnly = true;
234 std::string str = "string";
235 EXPECT_EQ(sharedBlock->PutBlobOrString(sharedBlock->mHeader->rowNums, 1, &str, str.size(), 1),
236 SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
237 sharedBlock->mReadOnly = false;
238 EXPECT_EQ(sharedBlock->PutBlobOrString(sharedBlock->mHeader->rowNums, 1, &str, str.size(), 1),
239 SharedBlock::SHARED_BLOCK_BAD_VALUE);
240 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
241 LOG_INFO("PutBlobOrStringTest001::End");
242 }
243
244 HWTEST_F(SharedBlockTest, PutLongTest001, TestSize.Level0)
245 {
246 LOG_INFO("PutLongTest001::Start");
247 AppDataFwk::SharedBlock *sharedBlock = nullptr;
248 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
249 SharedBlock::SHARED_BLOCK_OK);
250 EXPECT_NE(sharedBlock, nullptr);
251 int64_t temp = 0;
252 sharedBlock->mReadOnly = true;
253 EXPECT_EQ(
254 sharedBlock->PutLong(sharedBlock->mHeader->rowNums, 1, temp), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
255 sharedBlock->mReadOnly = false;
256 EXPECT_EQ(sharedBlock->PutLong(sharedBlock->mHeader->rowNums, 1, temp), SharedBlock::SHARED_BLOCK_BAD_VALUE);
257 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
258 LOG_INFO("PutLongTest001::End");
259 }
260
261 HWTEST_F(SharedBlockTest, PutDoubleTest001, TestSize.Level0)
262 {
263 LOG_INFO("PutDoubleTest001::Start");
264 AppDataFwk::SharedBlock *sharedBlock = nullptr;
265 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
266 SharedBlock::SHARED_BLOCK_OK);
267 EXPECT_NE(sharedBlock, nullptr);
268 double temp = 0;
269 sharedBlock->mReadOnly = true;
270 EXPECT_EQ(
271 sharedBlock->PutDouble(sharedBlock->mHeader->rowNums, 1, temp), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
272 sharedBlock->mReadOnly = false;
273 EXPECT_EQ(sharedBlock->PutDouble(sharedBlock->mHeader->rowNums, 1, temp), SharedBlock::SHARED_BLOCK_BAD_VALUE);
274 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
275 LOG_INFO("PutDoubleTest001::End");
276 }
277
278 HWTEST_F(SharedBlockTest, PutNullTest001, TestSize.Level0)
279 {
280 LOG_INFO("PutNullTest001::Start");
281 AppDataFwk::SharedBlock *sharedBlock = nullptr;
282 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
283 SharedBlock::SHARED_BLOCK_OK);
284 EXPECT_NE(sharedBlock, nullptr);
285 sharedBlock->mReadOnly = true;
286 EXPECT_EQ(sharedBlock->PutNull(sharedBlock->mHeader->rowNums, 1), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
287 sharedBlock->mReadOnly = false;
288 EXPECT_EQ(sharedBlock->PutNull(sharedBlock->mHeader->rowNums, 1), SharedBlock::SHARED_BLOCK_BAD_VALUE);
289 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
290 LOG_INFO("PutNullTest001::End");
291 }
292
293 HWTEST_F(SharedBlockTest, SetRawDataTest001, TestSize.Level0)
294 {
295 LOG_INFO("SetRawDataTest001::Start");
296 AppDataFwk::SharedBlock *sharedBlock = nullptr;
297 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
298 SharedBlock::SHARED_BLOCK_OK);
299 EXPECT_NE(sharedBlock, nullptr);
300 auto sizeTemp = sharedBlock->mSize;
301 sharedBlock->mSize = 0;
302 SharedBlock::SharedBlockHeader mHeader;
303 int result = memcpy_s(&mHeader, sizeof(mHeader), sharedBlock->mHeader, sizeof(mHeader));
304 EXPECT_EQ(result, 0);
305 EXPECT_EQ(sharedBlock->SetRawData(&mHeader, 0), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
306 EXPECT_EQ(sharedBlock->SetRawData(&mHeader, sizeof(mHeader)), SharedBlock::SHARED_BLOCK_NO_MEMORY);
307 sharedBlock->mSize = sizeTemp;
308 EXPECT_EQ(sharedBlock->SetRawData(&mHeader, sizeof(mHeader)), SharedBlock::SHARED_BLOCK_OK);
309 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
310 LOG_INFO("SetRawDataTest001::End");
311 }
312 } // namespace DataShare
313 } // namespace OHOS