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
25namespace OHOS {
26namespace UserIam {
27namespace UserAuth {
28using namespace testing;
29using namespace testing::ext;
30
31class AttributeTest : public testing::Test {
32public:
33    static void SetUpTestCase() {};
34
35    static void TearDownTestCase() {};
36
37    void SetUp() {};
38
39    void TearDown() {};
40};
41
42void 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
51HWTEST_F(AttributeTest, TestCreateEmptyAttribute_001, TestSize.Level0)
52{
53    MockMemMgr mock;
54    EXPECT_CALL(mock, Malloc(_))
55        .WillOnce(Return(nullptr))
56        .WillRepeatedly(
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(
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
82HWTEST_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
95HWTEST_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
116HWTEST_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
134HWTEST_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
155HWTEST_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
173HWTEST_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
194HWTEST_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
212HWTEST_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
234HWTEST_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
261HWTEST_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(
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(
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
301HWTEST_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
319HWTEST_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
341HWTEST_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
369HWTEST_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(
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(
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
407HWTEST_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
425HWTEST_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
447HWTEST_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(
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(
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
483HWTEST_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
520HWTEST_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
555HWTEST_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