1 /*
2 * Copyright (C) 2023 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 "attribute.h"
17
18 #include <cstdint>
19 #include <vector>
20 #include <gtest/gtest.h>
21
22 #include "securec.h"
23 #include "mock_adaptor_memory.h"
24
25 namespace OHOS {
26 namespace UserIam {
27 namespace UserAuth {
28 using namespace testing;
29 using namespace testing::ext;
30
31 class AttributeTest : public testing::Test {
32 public:
SetUpTestCase()33 static void SetUpTestCase() {};
34
TearDownTestCase()35 static void TearDownTestCase() {};
36
SetUp()37 void SetUp() {};
38
TearDown()39 void TearDown() {};
40 };
41
RandomFillVector(std::vector<uint8_t> & src,uint32_t len)42 void RandomFillVector(std::vector<uint8_t> &src, uint32_t len)
43 {
44 constexpr uint32_t mod = 128;
45 for (uint32_t i = 0; i < len; ++i) {
46 uint32_t num = static_cast<uint32_t>(rand());
47 src.push_back(static_cast<uint8_t>(num % mod));
48 }
49 }
50
51 HWTEST_F(AttributeTest, TestCreateEmptyAttribute_001, TestSize.Level0)
52 {
53 MockMemMgr mock;
54 EXPECT_CALL(mock, Malloc(_))
55 .WillOnce(Return(nullptr))
56 .WillRepeatedly(
__anon1eff63ad0102(const size_t size) 57 [](const size_t size) {
58 void *res = malloc(size);
59 static_cast<void>(memset_s(res, size, 0, size));
60 return res;
61 }
62 );
63
64 EXPECT_CALL(mock, Free(_))
65 .WillRepeatedly(
__anon1eff63ad0202(void *ptr) 66 [](void *ptr) {
67 if (ptr != nullptr) {
68 free(ptr);
69 }
70 }
71 );
72
73 Attribute *attribute = CreateEmptyAttribute();
74 ASSERT_EQ(attribute, nullptr);
75
76 attribute = CreateEmptyAttribute();
77 ASSERT_NE(attribute, nullptr);
78
79 FreeAttribute(&attribute);
80 }
81
82 HWTEST_F(AttributeTest, TestFreeAttribute_001, TestSize.Level0)
83 {
84 FreeAttribute(nullptr);
85 Attribute *attribute = nullptr;
86 FreeAttribute(&attribute);
87
88 attribute = CreateEmptyAttribute();
89 ASSERT_NE(attribute, nullptr);
90
91 FreeAttribute(&attribute);
92 ASSERT_EQ(attribute, nullptr);
93 }
94
95 HWTEST_F(AttributeTest, TestAttributeUint32_001, TestSize.Level0)
96 {
97 Attribute *attribute = CreateEmptyAttribute();
98 ASSERT_NE(attribute, nullptr);
99
100 constexpr uint32_t value1 = 6036;
101 constexpr uint32_t value2 = 5697;
102 ASSERT_EQ(SetAttributeUint32(attribute, ATTR_LOCKOUT_DURATION, value1), RESULT_SUCCESS);
103 ASSERT_EQ(SetAttributeUint32(attribute, ATTR_PROPERTY_MODE, value2), RESULT_SUCCESS);
104
105 uint32_t out1 = 0;
106 uint32_t out2 = 0;
107 ASSERT_EQ(GetAttributeUint32(attribute, ATTR_LOCKOUT_DURATION, &out1), RESULT_SUCCESS);
108 ASSERT_EQ(GetAttributeUint32(attribute, ATTR_PROPERTY_MODE, &out2), RESULT_SUCCESS);
109
110 ASSERT_EQ(out1, value1);
111 ASSERT_EQ(out2, value2);
112
113 FreeAttribute(&attribute);
114 }
115
116 HWTEST_F(AttributeTest, TestAttributeUint32_002, TestSize.Level0)
117 {
118 Attribute *attribute = CreateEmptyAttribute();
119 ASSERT_NE(attribute, nullptr);
120
121 constexpr uint32_t value = 6036;
122 ASSERT_EQ(SetAttributeUint32(nullptr, ATTR_LOCKOUT_DURATION, value), RESULT_BAD_PARAM);
123 ASSERT_EQ(SetAttributeUint32(attribute, ATTR_LOCKOUT_DURATION, value), RESULT_SUCCESS);
124
125 uint32_t out = 0;
126 ASSERT_EQ(GetAttributeUint32(nullptr, ATTR_LOCKOUT_DURATION, &out), RESULT_BAD_PARAM);
127 ASSERT_EQ(GetAttributeUint32(attribute, ATTR_LOCKOUT_DURATION, nullptr), RESULT_BAD_PARAM);
128 ASSERT_EQ(GetAttributeUint32(attribute, ATTR_PROPERTY_MODE, &out), RESULT_GENERAL_ERROR);
129 ASSERT_EQ(GetAttributeUint32(attribute, ATTR_LOCKOUT_DURATION, &out), RESULT_SUCCESS);
130
131 FreeAttribute(&attribute);
132 }
133
134 HWTEST_F(AttributeTest, TestAttributeInt32_001, TestSize.Level0)
135 {
136 Attribute *attribute = CreateEmptyAttribute();
137 ASSERT_NE(attribute, nullptr);
138
139 constexpr int32_t value1 = 6036;
140 constexpr int32_t value2 = 5697;
141 ASSERT_EQ(SetAttributeInt32(attribute, ATTR_RESULT_CODE, value1), RESULT_SUCCESS);
142 ASSERT_EQ(SetAttributeInt32(attribute, ATTR_REMAIN_ATTEMPTS, value2), RESULT_SUCCESS);
143
144 int32_t out1 = 0;
145 int32_t out2 = 0;
146 ASSERT_EQ(GetAttributeInt32(attribute, ATTR_RESULT_CODE, &out1), RESULT_SUCCESS);
147 ASSERT_EQ(GetAttributeInt32(attribute, ATTR_REMAIN_ATTEMPTS, &out2), RESULT_SUCCESS);
148
149 ASSERT_EQ(out1, value1);
150 ASSERT_EQ(out2, value2);
151
152 FreeAttribute(&attribute);
153 }
154
155 HWTEST_F(AttributeTest, TestAttributeInt32_002, TestSize.Level0)
156 {
157 Attribute *attribute = CreateEmptyAttribute();
158 ASSERT_NE(attribute, nullptr);
159
160 constexpr int32_t value = 6036;
161 ASSERT_EQ(SetAttributeInt32(nullptr, ATTR_RESULT_CODE, value), RESULT_BAD_PARAM);
162 ASSERT_EQ(SetAttributeInt32(attribute, ATTR_RESULT_CODE, value), RESULT_SUCCESS);
163
164 int32_t out = 0;
165 ASSERT_EQ(GetAttributeInt32(nullptr, ATTR_RESULT_CODE, &out), RESULT_BAD_PARAM);
166 ASSERT_EQ(GetAttributeInt32(attribute, ATTR_RESULT_CODE, nullptr), RESULT_BAD_PARAM);
167 ASSERT_EQ(GetAttributeInt32(attribute, ATTR_REMAIN_ATTEMPTS, &out), RESULT_GENERAL_ERROR);
168 ASSERT_EQ(GetAttributeInt32(attribute, ATTR_RESULT_CODE, &out), RESULT_SUCCESS);
169
170 FreeAttribute(&attribute);
171 }
172
173 HWTEST_F(AttributeTest, TestAttributeUint64_001, TestSize.Level0)
174 {
175 Attribute *attribute = CreateEmptyAttribute();
176 ASSERT_NE(attribute, nullptr);
177
178 constexpr uint64_t value1 = 6036;
179 constexpr uint64_t value2 = 5697;
180 ASSERT_EQ(SetAttributeUint64(attribute, ATTR_TEMPLATE_ID, value1), RESULT_SUCCESS);
181 ASSERT_EQ(SetAttributeUint64(attribute, ATTR_SCHEDULE_ID, value2), RESULT_SUCCESS);
182
183 uint64_t out1 = 0;
184 uint64_t out2 = 0;
185 ASSERT_EQ(GetAttributeUint64(attribute, ATTR_TEMPLATE_ID, &out1), RESULT_SUCCESS);
186 ASSERT_EQ(GetAttributeUint64(attribute, ATTR_SCHEDULE_ID, &out2), RESULT_SUCCESS);
187
188 ASSERT_EQ(out1, value1);
189 ASSERT_EQ(out2, value2);
190
191 FreeAttribute(&attribute);
192 }
193
194 HWTEST_F(AttributeTest, TestAttributeUint64_002, TestSize.Level0)
195 {
196 Attribute *attribute = CreateEmptyAttribute();
197 ASSERT_NE(attribute, nullptr);
198
199 constexpr uint64_t value = 6036;
200 ASSERT_EQ(SetAttributeUint64(nullptr, ATTR_TEMPLATE_ID, value), RESULT_BAD_PARAM);
201 ASSERT_EQ(SetAttributeUint64(attribute, ATTR_TEMPLATE_ID, value), RESULT_SUCCESS);
202
203 uint64_t out = 0;
204 ASSERT_EQ(GetAttributeUint64(nullptr, ATTR_TEMPLATE_ID, &out), RESULT_BAD_PARAM);
205 ASSERT_EQ(GetAttributeUint64(attribute, ATTR_TEMPLATE_ID, nullptr), RESULT_BAD_PARAM);
206 ASSERT_EQ(GetAttributeUint64(attribute, ATTR_SCHEDULE_ID, &out), RESULT_GENERAL_ERROR);
207 ASSERT_EQ(GetAttributeUint64(attribute, ATTR_TEMPLATE_ID, &out), RESULT_SUCCESS);
208
209 FreeAttribute(&attribute);
210 }
211
212 HWTEST_F(AttributeTest, TestAttributeUint8Array_001, TestSize.Level0)
213 {
214 Attribute *attribute = CreateEmptyAttribute();
215 ASSERT_NE(attribute, nullptr);
216
217 constexpr uint8_t size = 252;
218 std::vector<uint8_t> array;
219 array.reserve(size);
220 for (uint8_t i = 0; i < size; ++i) {
221 array.push_back(i);
222 }
223 Uint8Array data = { array.data(), size };
224 ASSERT_EQ(SetAttributeUint8Array(attribute, ATTR_SIGNATURE, data), RESULT_SUCCESS);
225
226 std::vector<uint8_t> out(size);
227 Uint8Array value = { out.data(), size };
228 ASSERT_EQ(GetAttributeUint8Array(attribute, ATTR_SIGNATURE, &value), RESULT_SUCCESS);
229 ASSERT_THAT(out, ElementsAreArray(array));
230
231 FreeAttribute(&attribute);
232 }
233
234 HWTEST_F(AttributeTest, TestAttributeUint8Array_002, TestSize.Level0)
235 {
236 Attribute *attribute = CreateEmptyAttribute();
237 ASSERT_NE(attribute, nullptr);
238
239 ASSERT_EQ(GetAttributeUint8Array(nullptr, ATTR_SIGNATURE, nullptr), RESULT_BAD_PARAM);
240 ASSERT_EQ(GetAttributeUint8Array(attribute, ATTR_SIGNATURE, nullptr), RESULT_BAD_PARAM);
241 Uint8Array value = {};
242 ASSERT_EQ(GetAttributeUint8Array(attribute, ATTR_SIGNATURE, &value), RESULT_BAD_PARAM);
243 constexpr uint32_t size = 20;
244 std::vector<uint8_t> array(size);
245 value = { array.data(), 0 };
246 ASSERT_EQ(GetAttributeUint8Array(attribute, ATTR_SIGNATURE, &value), RESULT_BAD_PARAM);
247
248 value = { array.data(), static_cast<uint32_t>(array.size()) };
249 constexpr uint32_t invalidKey = 100000032;
250 ASSERT_EQ(GetAttributeUint8Array(attribute, ATTR_CALLER_UID, &value), RESULT_GENERAL_ERROR);
251 ASSERT_EQ(GetAttributeUint8Array(attribute, static_cast<AttributeKey>(invalidKey), &value), RESULT_GENERAL_ERROR);
252
253 std::vector<uint8_t> out(size + size);
254 Uint8Array data = { out.data(), static_cast<uint32_t>(out.size()) };
255 ASSERT_EQ(SetAttributeUint8Array(attribute, ATTR_SIGNATURE, data), RESULT_SUCCESS);
256 ASSERT_EQ(GetAttributeUint8Array(attribute, ATTR_SIGNATURE, &value), RESULT_GENERAL_ERROR);
257
258 FreeAttribute(&attribute);
259 }
260
261 HWTEST_F(AttributeTest, TestAttributeUint8Array_003, TestSize.Level0)
262 {
263 Attribute *attribute = CreateEmptyAttribute();
264 ASSERT_NE(attribute, nullptr);
265
266 std::vector<uint8_t> array = {12, 14, 16, 15, 34, 123, 154, 48, 154, 102, 188};
267 Uint8Array data = { nullptr, static_cast<uint32_t>(array.size()) };
268 ASSERT_EQ(SetAttributeUint8Array(nullptr, ATTR_SIGNATURE, data), RESULT_BAD_PARAM);
269 ASSERT_EQ(SetAttributeUint8Array(attribute, ATTR_SIGNATURE, data), RESULT_BAD_PARAM);
270
271 data = { array.data(), static_cast<uint32_t>(array.size()) };
272 constexpr uint32_t invalidKey = 100000032;
273 ASSERT_EQ(SetAttributeUint8Array(attribute, static_cast<AttributeKey>(invalidKey), data), RESULT_GENERAL_ERROR);
274
275 MockMemMgr mock;
276 EXPECT_CALL(mock, Malloc(_))
277 .WillOnce(Return(nullptr))
278 .WillRepeatedly(
__anon1eff63ad0302(const size_t size) 279 [](const size_t size) {
280 void *res = malloc(size);
281 static_cast<void>(memset_s(res, size, 0, size));
282 return res;
283 }
284 );
285
286 EXPECT_CALL(mock, Free(_))
287 .WillRepeatedly(
__anon1eff63ad0402(void *ptr) 288 [](void *ptr) {
289 if (ptr != nullptr) {
290 free(ptr);
291 }
292 }
293 );
294
295 ASSERT_EQ(SetAttributeUint8Array(attribute, ATTR_SIGNATURE, data), RESULT_GENERAL_ERROR);
296 ASSERT_EQ(SetAttributeUint8Array(attribute, ATTR_SIGNATURE, data), RESULT_SUCCESS);
297
298 FreeAttribute(&attribute);
299 }
300
301 HWTEST_F(AttributeTest, TestSetEmptyUint8Array_001, TestSize.Level0)
302 {
303 Attribute *attribute = CreateEmptyAttribute();
304 ASSERT_NE(attribute, nullptr);
305
306 Uint8Array data = {};
307 ASSERT_EQ(SetAttributeUint8Array(attribute, ATTR_SIGNATURE, data), RESULT_SUCCESS);
308
309 constexpr uint32_t size = 20;
310 std::vector<uint8_t> array(size);
311 Uint8Array value = { array.data(), static_cast<uint32_t>(array.size()) };
312 ASSERT_EQ(GetAttributeUint8Array(attribute, ATTR_SIGNATURE, &value), RESULT_SUCCESS);
313
314 ASSERT_EQ(value.len, 0);
315
316 FreeAttribute(&attribute);
317 }
318
319 HWTEST_F(AttributeTest, TestAttributeUint64Array_001, TestSize.Level0)
320 {
321 Attribute *attribute = CreateEmptyAttribute();
322 ASSERT_NE(attribute, nullptr);
323
324 constexpr uint64_t size = 8192;
325 std::vector<uint64_t> array;
326 array.reserve(size);
327 for (uint64_t i = 0; i < size; ++i) {
328 array.push_back(i);
329 }
330 Uint64Array data = { array.data(), size };
331 ASSERT_EQ(SetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, data), RESULT_SUCCESS);
332
333 std::vector<uint64_t> out(size);
334 Uint64Array value = { out.data(), size };
335 ASSERT_EQ(GetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, &value), RESULT_SUCCESS);
336 ASSERT_THAT(out, ElementsAreArray(array));
337
338 FreeAttribute(&attribute);
339 }
340
341 HWTEST_F(AttributeTest, TestAttributeUint64Array_002, TestSize.Level0)
342 {
343 Attribute *attribute = CreateEmptyAttribute();
344 ASSERT_NE(attribute, nullptr);
345
346 ASSERT_EQ(GetAttributeUint64Array(nullptr, ATTR_TEMPLATE_ID_LIST, nullptr), RESULT_BAD_PARAM);
347 ASSERT_EQ(GetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, nullptr), RESULT_BAD_PARAM);
348 Uint64Array value = {};
349 ASSERT_EQ(GetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, &value), RESULT_BAD_PARAM);
350 constexpr uint32_t size = 20;
351 std::vector<uint64_t> array(size);
352 value = { array.data(), 0 };
353 ASSERT_EQ(GetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, &value), RESULT_BAD_PARAM);
354
355 value = { array.data(), static_cast<uint32_t>(array.size()) };
356 constexpr uint32_t invalidKey = 100000032;
357 ASSERT_EQ(GetAttributeUint64Array(attribute, ATTR_CALLER_UID, &value), RESULT_GENERAL_ERROR);
358 ASSERT_EQ(GetAttributeUint64Array(attribute, static_cast<AttributeKey>(invalidKey), &value),
359 RESULT_GENERAL_ERROR);
360
361 std::vector<uint8_t> temp(size);
362 Uint8Array data = { temp.data(), static_cast<uint32_t>(temp.size()) };
363 ASSERT_EQ(SetAttributeUint8Array(attribute, ATTR_SIGNATURE, data), RESULT_SUCCESS);
364 ASSERT_EQ(GetAttributeUint64Array(attribute, ATTR_SIGNATURE, &value), RESULT_GENERAL_ERROR);
365
366 FreeAttribute(&attribute);
367 }
368
369 HWTEST_F(AttributeTest, TestAttributeUint64Array_003, TestSize.Level0)
370 {
371 Attribute *attribute = CreateEmptyAttribute();
372 ASSERT_NE(attribute, nullptr);
373
374 std::vector<uint64_t> array = {12, 14, 16, 15, 34, 123, 154, 48, 154, 102, 188};
375 Uint64Array data = { nullptr, static_cast<uint32_t>(array.size()) };
376 ASSERT_EQ(SetAttributeUint64Array(nullptr, ATTR_TEMPLATE_ID_LIST, data), RESULT_BAD_PARAM);
377 ASSERT_EQ(SetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, data), RESULT_BAD_PARAM);
378
379 data = { array.data(), static_cast<uint32_t>(array.size()) };
380
381 MockMemMgr mock;
382 EXPECT_CALL(mock, Malloc(_))
383 .WillOnce(Return(nullptr))
384 .WillRepeatedly(
__anon1eff63ad0502(const size_t size) 385 [](const size_t size) {
386 void *res = malloc(size);
387 static_cast<void>(memset_s(res, size, 0, size));
388 return res;
389 }
390 );
391
392 EXPECT_CALL(mock, Free(_))
393 .WillRepeatedly(
__anon1eff63ad0602(void *ptr) 394 [](void *ptr) {
395 if (ptr != nullptr) {
396 free(ptr);
397 }
398 }
399 );
400
401 ASSERT_EQ(SetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, data), RESULT_GENERAL_ERROR);
402 ASSERT_EQ(SetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, data), RESULT_SUCCESS);
403
404 FreeAttribute(&attribute);
405 }
406
407 HWTEST_F(AttributeTest, TestSetEmptyUint64Array_001, TestSize.Level0)
408 {
409 Attribute *attribute = CreateEmptyAttribute();
410 ASSERT_NE(attribute, nullptr);
411
412 Uint64Array data = {};
413 ASSERT_EQ(SetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, data), RESULT_SUCCESS);
414
415 constexpr uint32_t size = 20;
416 std::vector<uint64_t> array(size);
417 Uint64Array value = { array.data(), static_cast<uint32_t>(array.size()) };
418 ASSERT_EQ(GetAttributeUint64Array(attribute, ATTR_TEMPLATE_ID_LIST, &value), RESULT_SUCCESS);
419
420 ASSERT_EQ(value.len, 0);
421
422 FreeAttribute(&attribute);
423 }
424
425 HWTEST_F(AttributeTest, TestGetAttributeSerializedMsg_001, TestSize.Level0)
426 {
427 ASSERT_EQ(GetAttributeSerializedMsg(nullptr, nullptr), RESULT_BAD_PARAM);
428
429 Attribute *attribute = CreateEmptyAttribute();
430 ASSERT_NE(attribute, nullptr);
431 ASSERT_EQ(GetAttributeSerializedMsg(attribute, nullptr), RESULT_BAD_PARAM);
432
433 Uint8Array retMsg = { nullptr, 0 };
434 ASSERT_EQ(GetAttributeSerializedMsg(attribute, &retMsg), RESULT_BAD_PARAM);
435
436 constexpr uint32_t size = 20;
437 std::vector<uint8_t> temp(size);
438 retMsg = { temp.data(), 0 };
439 ASSERT_EQ(GetAttributeSerializedMsg(attribute, &retMsg), RESULT_BAD_PARAM);
440
441 retMsg = { temp.data(), static_cast<uint32_t>(temp.size()) };
442 ASSERT_EQ(GetAttributeSerializedMsg(attribute, &retMsg), RESULT_SUCCESS);
443
444 FreeAttribute(&attribute);
445 }
446
447 HWTEST_F(AttributeTest, TestCreateAttributeFromSerializedMsg_001, TestSize.Level0)
448 {
449 Uint8Array msg = { nullptr, 0 };
450 ASSERT_EQ(CreateAttributeFromSerializedMsg(msg), nullptr);
451
452 constexpr uint32_t size = 20;
453 std::vector<uint8_t> temp(size);
454 msg = { temp.data(), 0 };
455 ASSERT_EQ(CreateAttributeFromSerializedMsg(msg), nullptr);
456
457 MockMemMgr mock;
458 EXPECT_CALL(mock, Malloc(_))
459 .WillOnce(Return(nullptr))
460 .WillOnce(
__anon1eff63ad0702(const size_t size) 461 [](const size_t size) {
462 void *res = malloc(size);
463 static_cast<void>(memset_s(res, size, 0, size));
464 return res;
465 }
466 )
467 .WillRepeatedly(Return(nullptr));
468
469 EXPECT_CALL(mock, Free(_))
470 .WillRepeatedly(
__anon1eff63ad0802(void *ptr) 471 [](void *ptr) {
472 if (ptr != nullptr) {
473 free(ptr);
474 }
475 }
476 );
477
478 msg = { temp.data(), static_cast<uint32_t>(temp.size()) };
479 ASSERT_EQ(CreateAttributeFromSerializedMsg(msg), nullptr);
480 ASSERT_EQ(CreateAttributeFromSerializedMsg(msg), nullptr);
481 }
482
483 HWTEST_F(AttributeTest, TestAttributeDeserialize, TestSize.Level0)
484 {
485 const std::vector<AttributeKey> keys = {ATTR_RESULT_CODE, ATTR_SIGNATURE, ATTR_DATA,
486 ATTR_REMAIN_ATTEMPTS, ATTR_SCHEDULE_MODE, ATTR_LOCKOUT_DURATION, ATTR_SCHEDULE_ID, ATTR_ROOT_SECRET};
487 constexpr uint32_t lenBase = 100;
488 constexpr uint32_t maxBufferLen = 2000;
489 std::vector<uint8_t> msg;
490 msg.reserve(maxBufferLen);
491 std::vector<std::vector<uint8_t>> rawValues;
492 for (const auto key : keys) {
493 std::vector<uint8_t> type(sizeof(uint32_t));
494 std::vector<uint8_t> len(sizeof(uint32_t));
495 std::vector<uint8_t> value;
496 uint32_t size = rand() % lenBase + 1;
497 static_cast<void>(memcpy_s(type.data(), type.size(), &key, sizeof(key)));
498 static_cast<void>(memcpy_s(len.data(), len.size(), &size, sizeof(size)));
499 RandomFillVector(value, size);
500 msg.insert(msg.end(), type.begin(), type.end());
501 msg.insert(msg.end(), len.begin(), len.end());
502 msg.insert(msg.end(), value.begin(), value.end());
503 rawValues.emplace_back(value);
504 }
505
506 Uint8Array data = { msg.data(), static_cast<uint32_t>(msg.size()) };
507 Attribute *attribute = CreateAttributeFromSerializedMsg(data);
508
509 for (uint32_t i = 0; i < keys.size(); ++i) {
510 std::vector<uint8_t> out(lenBase);
511 Uint8Array value = { out.data(), static_cast<uint32_t>(out.size()) };
512 ASSERT_EQ(GetAttributeUint8Array(attribute, keys[i], &value), RESULT_SUCCESS);
513 out.resize(value.len);
514 ASSERT_THAT(rawValues[i], ElementsAreArray(out));
515 }
516
517 FreeAttribute(&attribute);
518 }
519
520 HWTEST_F(AttributeTest, TestAttributeSetAndGet_001, TestSize.Level0)
521 {
522 constexpr uint32_t maxBufferLen = 1000;
523 Attribute *originAttribute = CreateEmptyAttribute();
524 EXPECT_NE(originAttribute, nullptr);
525 uint32_t testUint32 = 123;
526 int32_t testInt32 = 123;
527 uint64_t testUint64 = 456;
528 ResultCode result = SetAttributeUint32(originAttribute, ATTR_IDENTIFY_MODE, testUint32);
529 EXPECT_EQ(result, RESULT_SUCCESS);
530 result = SetAttributeInt32(originAttribute, ATTR_RESULT_CODE, testInt32);
531 EXPECT_EQ(result, RESULT_SUCCESS);
532 result = SetAttributeUint64(originAttribute, ATTR_SCHEDULE_ID, testUint64);
533 EXPECT_EQ(result, RESULT_SUCCESS);
534 uint8_t msgBuffer[maxBufferLen] = {};
535 Uint8Array msg = { msgBuffer, sizeof(msgBuffer) / sizeof(msgBuffer[0]) };
536 result = GetAttributeSerializedMsg(originAttribute, &msg);
537 EXPECT_EQ(result, RESULT_SUCCESS);
538 FreeAttribute(&originAttribute);
539
540 uint32_t parsedUint32;
541 int32_t parsedInt32;
542 uint64_t parsedUint64;
543 Attribute *parsedAttribute = CreateAttributeFromSerializedMsg(msg);
544 result = GetAttributeUint32(parsedAttribute, ATTR_IDENTIFY_MODE, &parsedUint32);
545 EXPECT_EQ(result, RESULT_SUCCESS);
546 EXPECT_EQ(parsedUint32, testUint32);
547 result = GetAttributeInt32(parsedAttribute, ATTR_RESULT_CODE, &parsedInt32);
548 EXPECT_EQ(parsedInt32, testInt32);
549 result = GetAttributeUint64(parsedAttribute, ATTR_SCHEDULE_ID, &parsedUint64);
550 EXPECT_EQ(result, RESULT_SUCCESS);
551 EXPECT_EQ(parsedUint64, testUint64);
552 FreeAttribute(&parsedAttribute);
553 }
554
555 HWTEST_F(AttributeTest, TestAttributeSetAndGet_002, TestSize.Level0)
556 {
557 constexpr uint32_t maxBufferLen = 1000;
558 Attribute *originAttribute = CreateEmptyAttribute();
559 EXPECT_NE(originAttribute, nullptr);
560 uint8_t testUint8Buffer[] = { 'a', 'b', 'c' };
561 uint64_t testUint64Buffer[] = { 123, 456, 789 };
562 Uint8Array testUint8Array = { testUint8Buffer, sizeof(testUint8Buffer) / sizeof(testUint8Buffer[0]) };
563 Uint64Array testUint64Array = { testUint64Buffer, sizeof(testUint64Buffer) / sizeof(testUint64Buffer[0]) };
564 ResultCode result = SetAttributeUint8Array(originAttribute, ATTR_SIGNATURE, testUint8Array);
565 EXPECT_EQ(result, RESULT_SUCCESS);
566 result = SetAttributeUint64Array(originAttribute, ATTR_TEMPLATE_ID_LIST, testUint64Array);
567 EXPECT_EQ(result, RESULT_SUCCESS);
568 uint8_t msgBuffer[maxBufferLen] = {};
569 Uint8Array msg = { msgBuffer, sizeof(msgBuffer) / sizeof(msgBuffer[0]) };
570 result = GetAttributeSerializedMsg(originAttribute, &msg);
571 EXPECT_EQ(result, RESULT_SUCCESS);
572 FreeAttribute(&originAttribute);
573
574 constexpr uint32_t maxSize = 10;
575 uint8_t parsedUint8Buffer[maxSize];
576 uint64_t parsedUint64Buffer[maxSize];
577 Uint8Array parsedUint8Array = { parsedUint8Buffer, sizeof(parsedUint8Buffer) / sizeof(parsedUint8Buffer[0]) };
578 Uint64Array parsedUint64Array = { parsedUint64Buffer, sizeof(parsedUint64Buffer) / sizeof(parsedUint64Buffer[0]) };
579 Attribute *parsedAttribute = CreateAttributeFromSerializedMsg(msg);
580 result = GetAttributeUint8Array(parsedAttribute, ATTR_SIGNATURE, &parsedUint8Array);
581 EXPECT_EQ(result, RESULT_SUCCESS);
582 EXPECT_EQ(testUint8Array.len, parsedUint8Array.len);
583 EXPECT_EQ(testUint8Array.data[2], parsedUint8Array.data[2]);
584 result = GetAttributeUint64Array(parsedAttribute, ATTR_TEMPLATE_ID_LIST, &parsedUint64Array);
585 EXPECT_EQ(result, RESULT_SUCCESS);
586 EXPECT_EQ(testUint64Array.len, parsedUint64Array.len);
587 EXPECT_EQ(testUint64Array.data[2], parsedUint64Array.data[2]);
588 FreeAttribute(&parsedAttribute);
589 }
590 } // namespace UserAuth
591 } // namespace UserIam
592 } // namespace OHOS