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 /**
54 * @tc.name: InitTest001
55 * @tc.desc: Test SharedBlock Init function when Ashmem start address is null
56 * @tc.type: FUNC
57 * @tc.require: None
58 * @tc.precon: None
59 * @tc.step:
60 1. Create an Ashmem instance named "ahsmem" with size equal to SharedBlockHeader
61 2. Set Ashmem's startAddr_ to nullptr
62 3. Create a SharedBlock instance with the Ashmem, name "name", offset 0, and read-only flag true
63 4. Call Init() on the SharedBlock instance
64 5. Check the return value of Init()
65 * @tc.expect: SharedBlock::Init() returns false (initialization fails due to null Ashmem start address)
66 */
67 HWTEST_F(SharedBlockTest, InitTest001, TestSize.Level0)
68 {
69 LOG_INFO("InitTest001::Start");
70 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("ahsmem", sizeof(SharedBlock::SharedBlockHeader));
71 EXPECT_NE(ashmem, nullptr);
72 ashmem->startAddr_ = nullptr;
73 SharedBlock *sharedBlock = new SharedBlock("name", ashmem, 0, true);
74 EXPECT_EQ(sharedBlock->Init(), false);
75 LOG_INFO("InitTest001::End");
76 }
77
78 /**
79 * @tc.name: CreateSharedBlockTest001
80 * @tc.desc: Test CreateSharedBlock function when Ashmem start address is null
81 * @tc.type: FUNC
82 * @tc.require: None
83 * @tc.precon: None
84 * @tc.step:
85 1. Create an Ashmem instance named "ahsmem" with size equal to SharedBlockHeader
86 2. Set Ashmem's startAddr_ to nullptr
87 3. Declare a null SharedBlock pointer
88 4. Call CreateSharedBlock with name "name", size equal to SharedBlockHeader, the Ashmem, and the null pointer
89 5. Check the return error code
90 * @tc.expect: CreateSharedBlock returns SharedBlock::SHARED_BLOCK_ASHMEM_ERROR
91 */
92 HWTEST_F(SharedBlockTest, CreateSharedBlockTest001, TestSize.Level0)
93 {
94 LOG_INFO("CreateSharedBlockTest001::Start");
95 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("ahsmem", sizeof(SharedBlock::SharedBlockHeader));
96 EXPECT_NE(ashmem, nullptr);
97 ashmem->startAddr_ = nullptr;
98 AppDataFwk::SharedBlock *sharedBlock = nullptr;
99 EXPECT_EQ(sharedBlock->CreateSharedBlock("name", sizeof(SharedBlock::SharedBlockHeader), ashmem, sharedBlock),
100 SharedBlock::SHARED_BLOCK_ASHMEM_ERROR);
101 LOG_INFO("CreateSharedBlockTest001::End");
102 }
103
104 /**
105 * @tc.name: CreateTest001
106 * @tc.desc: Test SharedBlock::Create function with negative size parameter
107 * @tc.type: FUNC
108 * @tc.require: None
109 * @tc.precon: None
110 * @tc.step:
111 1. Declare a null SharedBlock pointer
112 2. Call SharedBlock::Create with name "name", negative size (-1), and the null pointer
113 3. Check the return error code
114 * @tc.expect: SharedBlock::Create returns SharedBlock::SHARED_BLOCK_ASHMEM_ERROR
115 */
116 HWTEST_F(SharedBlockTest, CreateTest001, TestSize.Level0)
117 {
118 LOG_INFO("CreateTest001::Start");
119 AppDataFwk::SharedBlock *sharedBlock = nullptr;
120 EXPECT_EQ(SharedBlock::Create("name", -1, sharedBlock), SharedBlock::SHARED_BLOCK_ASHMEM_ERROR);
121 LOG_INFO("CreateTest001::End");
122 }
123
124 /**
125 * @tc.name: ReadMessageParcelTest001
126 * @tc.desc: Test SharedBlock::ReadMessageParcel function with valid parcel data
127 * @tc.type: FUNC
128 * @tc.require: None
129 * @tc.precon: None
130 * @tc.step:
131 1. Create a MessageParcel instance
132 2. Write a string16 ("string") and the Ashmem instance to the parcel
133 3. Declare a null SharedBlock pointer
134 4. Call SharedBlock::ReadMessageParcel with the parcel and the null pointer
135 5. Check the return error code
136 * @tc.expect: SharedBlock::ReadMessageParcel returns SharedBlock::SHARED_BLOCK_OK (successfully reads parcel data)
137 */
138 HWTEST_F(SharedBlockTest, ReadMessageParcelTest001, TestSize.Level0)
139 {
140 LOG_INFO("ReadMessageParcelTest001::Start");
141 MessageParcel parcel;
142 std::u16string str = u"string";
143 SharedBlock *block = nullptr;
144 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("ahsmem", sizeof(SharedBlock::SharedBlockHeader));
145 EXPECT_NE(ashmem, nullptr);
146 ashmem->startAddr_ = nullptr;
147 parcel.WriteString16(str);
148 parcel.WriteAshmem(ashmem);
149 EXPECT_EQ(SharedBlock::ReadMessageParcel(parcel, block), SharedBlock::SHARED_BLOCK_OK);
150
151 LOG_INFO("ReadMessageParcelTest001::End");
152 }
153
154 /**
155 * @tc.name: ClearTest001
156 * @tc.desc: Test SharedBlock Clear function under different states (read-only, insufficient size, normal)
157 * @tc.type: FUNC
158 * @tc.require: None
159 * @tc.precon: None
160 * @tc.step:
161 1. Create a SharedBlock instance with valid size, verify it is not null
162 2. Set the SharedBlock to read-only mode, call Clear() and check return code
163 3. Set the SharedBlock to read-write mode, set mSize to SharedBlockHeader size, call Clear and check return code
164 4. Restore mSize to original valid size, call Clear() and check return code
165 * @tc.expect:
166 - Clear() returns SHARED_BLOCK_INVALID_OPERATION when read-only
167 - Clear() returns SHARED_BLOCK_BAD_VALUE when size is insufficient
168 - Clear() returns SHARED_BLOCK_OK when in read-write mode with valid size
169 */
170 HWTEST_F(SharedBlockTest, ClearTest001, TestSize.Level0)
171 {
172 LOG_INFO("ClearTest001::Start");
173 AppDataFwk::SharedBlock *sharedBlock = nullptr;
174 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
175 SharedBlock::SHARED_BLOCK_OK);
176 EXPECT_NE(sharedBlock, nullptr);
177 sharedBlock->mReadOnly = true;
178 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
179 sharedBlock->mReadOnly = false;
180 sharedBlock->mSize = sizeof(SharedBlock::SharedBlockHeader);
181 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_BAD_VALUE);
182 sharedBlock->mSize = sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader);
183 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
184 LOG_INFO("ClearTest001::End");
185 }
186
187 /**
188 * @tc.name: SetColumnNumTest001
189 * @tc.desc: Test SetColumnNum function under various conditions (read-only, invalid values, max limit)
190 * @tc.type: FUNC
191 * @tc.require: None
192 * @tc.precon: None
193 * @tc.step:
194 1. Create a SharedBlock instance, verify it is not null
195 2. Set to read-only mode, call SetColumnNum(1) and check return code
196 3. Set to read-write mode, configure header with conflicting row/column nums, call SetColumnNum(0) and check
197 4. Test with max column num (32768) and conflicting row nums, check return code
198 5. Test valid configuration (matching row/column nums), check return code
199 6. Test setting column num to 0 with no rows, check return code
200 * @tc.expect:
201 - Returns SHARED_BLOCK_INVALID_OPERATION in read-only mode
202 - Returns SHARED_BLOCK_INVALID_OPERATION for invalid value combinations
203 - Returns SHARED_BLOCK_OK for valid configurations
204 */
205 HWTEST_F(SharedBlockTest, SetColumnNumTest001, TestSize.Level0)
206 {
207 LOG_INFO("SetColumnNumTest001::Start");
208 AppDataFwk::SharedBlock *sharedBlock = nullptr;
209 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
210 SharedBlock::SHARED_BLOCK_OK);
211 EXPECT_NE(sharedBlock, nullptr);
212 sharedBlock->mReadOnly = true;
213 uint32_t numColumns = 1;
214 EXPECT_EQ(sharedBlock->SetColumnNum(numColumns), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
215 sharedBlock->mReadOnly = false;
216 sharedBlock->mHeader->columnNums = numColumns;
217 sharedBlock->mHeader->rowNums = numColumns;
218 EXPECT_EQ(sharedBlock->SetColumnNum(0), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
219 sharedBlock->mHeader->columnNums = 0;
220 sharedBlock->mHeader->rowNums = numColumns;
221 EXPECT_EQ(sharedBlock->SetColumnNum(numColumns), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
222 sharedBlock->mHeader->columnNums = numColumns;
223 sharedBlock->mHeader->rowNums = 0;
224 EXPECT_EQ(sharedBlock->SetColumnNum(0), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
225 numColumns = 32768; // 32768 is max_num
226 sharedBlock->mHeader->columnNums = numColumns;
227 sharedBlock->mHeader->rowNums = numColumns;
228 EXPECT_EQ(sharedBlock->SetColumnNum(numColumns), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
229 numColumns = 1;
230 sharedBlock->mHeader->columnNums = numColumns;
231 sharedBlock->mHeader->rowNums = numColumns;
232 EXPECT_EQ(sharedBlock->SetColumnNum(numColumns), SharedBlock::SHARED_BLOCK_OK);
233 sharedBlock->mHeader->columnNums = 0;
234 sharedBlock->mHeader->rowNums = 0;
235 EXPECT_EQ(sharedBlock->SetColumnNum(0), SharedBlock::SHARED_BLOCK_OK);
236 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
237 LOG_INFO("SetColumnNumTest001::End");
238 }
239
240 /**
241 * @tc.name: AllocRowTest001
242 * @tc.desc: Test AllocRow function under read-only mode and insufficient memory
243 * @tc.type: FUNC
244 * @tc.require: None
245 * @tc.precon: None
246 * @tc.step:
247 1. Create a SharedBlock instance, verify it is not null
248 2. Set to read-only mode, call AllocRow() and check return code
249 3. Set to read-write mode, set mSize to 0 (insufficient memory), call AllocRow() and check return code
250 4. Restore mSize to valid value, call Clear() to clean up
251 * @tc.expect:
252 - AllocRow() returns SHARED_BLOCK_INVALID_OPERATION in read-only mode
253 - AllocRow() returns SHARED_BLOCK_NO_MEMORY when size is insufficient
254 - Clear() returns SHARED_BLOCK_OK after restoring size
255 */
256 HWTEST_F(SharedBlockTest, AllocRow, TestSize.Level0)
257 {
258 LOG_INFO("AllocRowTest001::Start");
259 AppDataFwk::SharedBlock *sharedBlock = nullptr;
260 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
261 SharedBlock::SHARED_BLOCK_OK);
262 EXPECT_NE(sharedBlock, nullptr);
263 sharedBlock->mReadOnly = true;
264 EXPECT_EQ(sharedBlock->AllocRow(), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
265 sharedBlock->mReadOnly = false;
266 sharedBlock->mSize = 0;
267 EXPECT_EQ(sharedBlock->AllocRow(), SharedBlock::SHARED_BLOCK_NO_MEMORY);
268 sharedBlock->mSize = sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader);
269 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
270 LOG_INFO("AllocRowTest001::End");
271 }
272
273 /**
274 * @tc.name: FreeLastRowTest001
275 * @tc.desc: Test FreeLastRow function under read-only mode and with different row counts
276 * @tc.type: FUNC
277 * @tc.require: None
278 * @tc.precon: None
279 * @tc.step:
280 1. Create a SharedBlock instance, verify it is not null
281 2. Set to read-only mode, call FreeLastRow() and check return code
282 3. Set to read-write mode, set rowNums to 0, call FreeLastRow() and check return code
283 4. Set rowNums to a positive value, call FreeLastRow() and check return code
284 5. Call Clear() to clean up
285 * @tc.expect:
286 - FreeLastRow() returns SHARED_BLOCK_INVALID_OPERATION in read-only mode
287 - FreeLastRow() returns SHARED_BLOCK_OK when rowNums is 0
288 - FreeLastRow() returns SHARED_BLOCK_OK when rowNums is positive
289 - Clear() returns SHARED_BLOCK_OK
290 */
291 HWTEST_F(SharedBlockTest, FreeLastRowTest001, TestSize.Level0)
292 {
293 LOG_INFO("FreeLastRowTest001::Start");
294 AppDataFwk::SharedBlock *sharedBlock = nullptr;
295 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
296 SharedBlock::SHARED_BLOCK_OK);
297 EXPECT_NE(sharedBlock, nullptr);
298 sharedBlock->mReadOnly = true;
299 EXPECT_EQ(sharedBlock->FreeLastRow(), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
300 sharedBlock->mReadOnly = false;
301 auto temp = sharedBlock->mHeader->rowNums + 1;
302 sharedBlock->mHeader->rowNums = 0;
303 EXPECT_EQ(sharedBlock->FreeLastRow(), SharedBlock::SHARED_BLOCK_OK);
304 sharedBlock->mHeader->rowNums = temp;
305 EXPECT_EQ(sharedBlock->FreeLastRow(), SharedBlock::SHARED_BLOCK_OK);
306 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
307 LOG_INFO("FreeLastRowTest001::End");
308 }
309
310 /**
311 * @tc.name: AllocRowOffsetTest001
312 * @tc.desc: Test AllocRowOffset function with insufficient memory
313 * @tc.type: FUNC
314 * @tc.require: None
315 * @tc.precon: None
316 * @tc.step:
317 1. Create a SharedBlock instance, verify it is not null
318 2. Save original mSize, set mSize to 0 (insufficient memory)
319 3. Call AllocRowOffset() and check return value
320 4. Restore mSize to original value, call Clear() to clean up
321 * @tc.expect:
322 - AllocRowOffset() returns nullptr when mSize is 0 (insufficient memory)
323 - Clear() returns SHARED_BLOCK_OK after restoring size
324 */
325 HWTEST_F(SharedBlockTest, AllocRowOffsetTest001, TestSize.Level0)
326 {
327 LOG_INFO("AllocRowOffsetTest001::Start");
328 AppDataFwk::SharedBlock *sharedBlock = nullptr;
329 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
330 SharedBlock::SHARED_BLOCK_OK);
331 EXPECT_NE(sharedBlock, nullptr);
332 auto temp = sharedBlock->mSize;
333 sharedBlock->mSize = 0;
334 EXPECT_EQ(sharedBlock->AllocRowOffset(), nullptr);
335 sharedBlock->mSize = temp;
336 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
337 LOG_INFO("AllocRowOffsetTest001::End");
338 }
339
340 /**
341 * @tc.name: GetCellUnitTest001
342 * @tc.desc: Test GetCellUnit function with invalid row/column indices and insufficient memory
343 * @tc.type: FUNC
344 * @tc.require: None
345 * @tc.precon: None
346 * @tc.step:
347 1. Create a SharedBlock instance, verify it is not null
348 2. Save original rowNums, columnNums, and mSize
349 3. Set rowNums=1, columnNums=1, mSize=0 (insufficient memory)
350 4. Call GetCellUnit with invalid row (1) and valid column (0), check return value
351 5. Call GetCellUnit with valid row (0) and invalid column (1), check return value
352 6. Call GetCellUnit with valid row/column (0,0), check return value
353 7. Restore original values, call Clear() to clean up
354 * @tc.expect: All GetCellUnit calls return nullptr under invalid conditions
355 */
356 HWTEST_F(SharedBlockTest, GetCellUnitTest001, TestSize.Level0)
357 {
358 LOG_INFO("GetCellUnitTest001::Start");
359 AppDataFwk::SharedBlock *sharedBlock = nullptr;
360 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
361 SharedBlock::SHARED_BLOCK_OK);
362 EXPECT_NE(sharedBlock, nullptr);
363 auto rowTemp = sharedBlock->mHeader->rowNums;
364 auto culTemp = sharedBlock->mHeader->columnNums;
365 auto sizeTemp = sharedBlock->mSize;
366 sharedBlock->mHeader->rowNums = 1;
367 sharedBlock->mHeader->columnNums = 1;
368 sharedBlock->mSize = 0;
369 EXPECT_EQ(sharedBlock->GetCellUnit(1, 0), nullptr);
370 EXPECT_EQ(sharedBlock->GetCellUnit(0, 1), nullptr);
371 EXPECT_EQ(sharedBlock->GetCellUnit(0, 0), nullptr);
372 sharedBlock->mHeader->rowNums = rowTemp;
373 sharedBlock->mHeader->columnNums = culTemp;
374 sharedBlock->mSize = sizeTemp;
375 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
376 LOG_INFO("GetCellUnitTest001::End");
377 }
378
379 /**
380 * @tc.name: PutBlobOrStringTest001
381 * @tc.desc: Test PutBlobOrString function under read-only mode and invalid indices
382 * @tc.type: FUNC
383 * @tc.require: None
384 * @tc.precon: None
385 * @tc.step:
386 1. Create a SharedBlock instance, verify it is not null
387 2. Set to read-only mode, call PutBlobOrString with valid parameters and check return code
388 3. Set to read-write mode, call PutBlobOrString with invalid row index and check return code
389 4. Call Clear() to clean up
390 * @tc.expect:
391 - Returns SHARED_BLOCK_INVALID_OPERATION in read-only mode
392 - Returns SHARED_BLOCK_BAD_VALUE with invalid row index
393 - Clear() returns SHARED_BLOCK_OK
394 */
395 HWTEST_F(SharedBlockTest, PutBlobOrStringTest001, TestSize.Level0)
396 {
397 LOG_INFO("PutBlobOrStringTest001::Start");
398 AppDataFwk::SharedBlock *sharedBlock = nullptr;
399 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
400 SharedBlock::SHARED_BLOCK_OK);
401 EXPECT_NE(sharedBlock, nullptr);
402 sharedBlock->mReadOnly = true;
403 std::string str = "string";
404 EXPECT_EQ(sharedBlock->PutBlobOrString(sharedBlock->mHeader->rowNums, 1, &str, str.size(), 1),
405 SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
406 sharedBlock->mReadOnly = false;
407 EXPECT_EQ(sharedBlock->PutBlobOrString(sharedBlock->mHeader->rowNums, 1, &str, str.size(), 1),
408 SharedBlock::SHARED_BLOCK_BAD_VALUE);
409 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
410 LOG_INFO("PutBlobOrStringTest001::End");
411 }
412
413 /**
414 * @tc.name: PutLongTest001
415 * @tc.desc: Test PutLong function under read-only mode and invalid indices
416 * @tc.type: FUNC
417 * @tc.require: None
418 * @tc.precon: None
419 * @tc.step:
420 1. Create a SharedBlock instance, verify it is not null
421 2. Set to read-only mode, call PutLong with invalid indices and check return code
422 3. Set to read-write mode, call PutLong with invalid indices and check return code
423 4. Call Clear() to clean up
424 * @tc.expect:
425 - Returns SHARED_BLOCK_INVALID_OPERATION in read-only mode
426 - Returns SHARED_BLOCK_BAD_VALUE with invalid indices
427 - Clear() returns SHARED_BLOCK_OK
428 */
429 HWTEST_F(SharedBlockTest, PutLongTest001, TestSize.Level0)
430 {
431 LOG_INFO("PutLongTest001::Start");
432 AppDataFwk::SharedBlock *sharedBlock = nullptr;
433 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
434 SharedBlock::SHARED_BLOCK_OK);
435 EXPECT_NE(sharedBlock, nullptr);
436 int64_t temp = 0;
437 sharedBlock->mReadOnly = true;
438 EXPECT_EQ(
439 sharedBlock->PutLong(sharedBlock->mHeader->rowNums, 1, temp), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
440 sharedBlock->mReadOnly = false;
441 EXPECT_EQ(sharedBlock->PutLong(sharedBlock->mHeader->rowNums, 1, temp), SharedBlock::SHARED_BLOCK_BAD_VALUE);
442 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
443 LOG_INFO("PutLongTest001::End");
444 }
445
446 /**
447 * @tc.name: PutDoubleTest001
448 * @tc.desc: Test PutDouble function under read-only mode and invalid indices
449 * @tc.type: FUNC
450 * @tc.require: None
451 * @tc.precon: None
452 * @tc.step:
453 1. Create a SharedBlock instance, verify it is not null
454 2. Set to read-only mode, call PutDouble with invalid indices and check return code
455 3. Set to read-write mode, call PutDouble with invalid indices and check return code
456 4. Call Clear() to clean up
457 * @tc.expect:
458 - Returns SHARED_BLOCK_INVALID_OPERATION in read-only mode
459 - Returns SHARED_BLOCK_BAD_VALUE with invalid indices
460 - Clear() returns SHARED_BLOCK_OK
461 */
462 HWTEST_F(SharedBlockTest, PutDoubleTest001, TestSize.Level0)
463 {
464 LOG_INFO("PutDoubleTest001::Start");
465 AppDataFwk::SharedBlock *sharedBlock = nullptr;
466 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
467 SharedBlock::SHARED_BLOCK_OK);
468 EXPECT_NE(sharedBlock, nullptr);
469 double temp = 0;
470 sharedBlock->mReadOnly = true;
471 EXPECT_EQ(
472 sharedBlock->PutDouble(sharedBlock->mHeader->rowNums, 1, temp), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
473 sharedBlock->mReadOnly = false;
474 EXPECT_EQ(sharedBlock->PutDouble(sharedBlock->mHeader->rowNums, 1, temp), SharedBlock::SHARED_BLOCK_BAD_VALUE);
475 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
476 LOG_INFO("PutDoubleTest001::End");
477 }
478
479 /**
480 * @tc.name: PutNullTest001
481 * @tc.desc: Test PutNull function under read-only mode and invalid indices
482 * @tc.type: FUNC
483 * @tc.require: None
484 * @tc.precon: None
485 * @tc.step:
486 1. Create a SharedBlock instance, verify it is not null
487 2. Set to read-only mode, call PutNull with invalid indices and check return code
488 3. Set to read-write mode, call PutNull with invalid indices and check return code
489 4. Call Clear() to clean up
490 * @tc.expect:
491 - Returns SHARED_BLOCK_INVALID_OPERATION in read-only mode
492 - Returns SHARED_BLOCK_BAD_VALUE with invalid indices
493 - Clear() returns SHARED_BLOCK_OK
494 */
495 HWTEST_F(SharedBlockTest, PutNullTest001, TestSize.Level0)
496 {
497 LOG_INFO("PutNullTest001::Start");
498 AppDataFwk::SharedBlock *sharedBlock = nullptr;
499 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
500 SharedBlock::SHARED_BLOCK_OK);
501 EXPECT_NE(sharedBlock, nullptr);
502 sharedBlock->mReadOnly = true;
503 EXPECT_EQ(sharedBlock->PutNull(sharedBlock->mHeader->rowNums, 1), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
504 sharedBlock->mReadOnly = false;
505 EXPECT_EQ(sharedBlock->PutNull(sharedBlock->mHeader->rowNums, 1), SharedBlock::SHARED_BLOCK_BAD_VALUE);
506 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
507 LOG_INFO("PutNullTest001::End");
508 }
509
510 /**
511 * @tc.name: SetRawDataTest001
512 * @tc.desc: Test SetRawData function with invalid size and insufficient memory
513 * @tc.type: FUNC
514 * @tc.require: None
515 * @tc.precon: None
516 * @tc.step:
517 1. Create a SharedBlock instance, verify it is not null
518 2. Save original mSize, set mSize to 0 (insufficient memory)
519 3. Call SetRawData with header data and size 0, check return code
520 4. Call SetRawData with header data and valid size, check return code
521 5. Restore mSize to original value, call SetRawData with valid size, check return code
522 6. Call Clear() to clean up
523 * @tc.expect:
524 - Returns SHARED_BLOCK_INVALID_OPERATION when size is 0
525 - Returns SHARED_BLOCK_NO_MEMORY when mSize is 0
526 - Returns SHARED_BLOCK_OK when mSize is valid
527 - Clear() returns SHARED_BLOCK_OK
528 */
529 HWTEST_F(SharedBlockTest, SetRawDataTest001, TestSize.Level0)
530 {
531 LOG_INFO("SetRawDataTest001::Start");
532 AppDataFwk::SharedBlock *sharedBlock = nullptr;
533 EXPECT_EQ(SharedBlock::Create("name", sizeof(SharedBlock) + sizeof(SharedBlock::SharedBlockHeader), sharedBlock),
534 SharedBlock::SHARED_BLOCK_OK);
535 EXPECT_NE(sharedBlock, nullptr);
536 auto sizeTemp = sharedBlock->mSize;
537 sharedBlock->mSize = 0;
538 SharedBlock::SharedBlockHeader mHeader;
539 int result = memcpy_s(&mHeader, sizeof(mHeader), sharedBlock->mHeader, sizeof(mHeader));
540 EXPECT_EQ(result, 0);
541 EXPECT_EQ(sharedBlock->SetRawData(&mHeader, 0), SharedBlock::SHARED_BLOCK_INVALID_OPERATION);
542 EXPECT_EQ(sharedBlock->SetRawData(&mHeader, sizeof(mHeader)), SharedBlock::SHARED_BLOCK_NO_MEMORY);
543 sharedBlock->mSize = sizeTemp;
544 EXPECT_EQ(sharedBlock->SetRawData(&mHeader, sizeof(mHeader)), SharedBlock::SHARED_BLOCK_OK);
545 EXPECT_EQ(sharedBlock->Clear(), SharedBlock::SHARED_BLOCK_OK);
546 LOG_INFO("SetRawDataTest001::End");
547 }
548 } // namespace DataShare
549 } // namespace OHOS