1 /*
2 * Copyright (C) 2022 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 "attributes_test.h"
17
18 #include <climits>
19
20 #include "attributes.h"
21
22 #include "iam_logger.h"
23 #include "securec.h"
24
25 #define LOG_TAG "USER_AUTH_SA"
26
27 namespace OHOS {
28 namespace UserIam {
29 namespace UserAuth {
30 using namespace testing;
31 using namespace testing::ext;
32
SetUpTestCase()33 void AttributesTest::SetUpTestCase()
34 {
35 }
36
TearDownTestCase()37 void AttributesTest::TearDownTestCase()
38 {
39 }
40
SetUp()41 void AttributesTest::SetUp()
42 {
43 }
44
TearDown()45 void AttributesTest::TearDown()
46 {
47 }
48
49 HWTEST_F(AttributesTest, AttributesInit, TestSize.Level0)
50 {
51 Attributes attrs;
52 EXPECT_EQ(attrs.Serialize().size(), 0U);
53 }
54
55 HWTEST_F(AttributesTest, AttributesSerialize, TestSize.Level0)
56 {
57 const std::vector<Attributes::AttributeKey> desired = {Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
58 Attributes::ATTR_TEMPLATE_ID_LIST, Attributes::ATTR_REMAIN_TIMES, Attributes::ATTR_FREEZING_TIME,
59 Attributes::ATTR_SCHEDULE_ID, Attributes::ATTR_SCHEDULE_MODE, Attributes::ATTR_CREDENTIAL_DIGEST};
60
61 Attributes attrs;
62
63 EXPECT_TRUE(attrs.SetBoolValue(Attributes::ATTR_RESULT_CODE, true));
64 EXPECT_TRUE(attrs.SetBoolValue(Attributes::ATTR_SIGNATURE, false));
65 EXPECT_TRUE(attrs.SetUint64Value(Attributes::ATTR_SCHEDULE_ID, UINT64_MAX));
66 EXPECT_TRUE(attrs.SetUint32ArrayValue(Attributes::ATTR_REMAIN_TIMES, {1, 3, 5, 7, 9}));
67 EXPECT_TRUE(attrs.SetUint32Value(Attributes::ATTR_SCHEDULE_MODE, UINT32_MAX));
68 EXPECT_TRUE(attrs.SetUint16Value(Attributes::ATTR_CREDENTIAL_DIGEST, UINT16_MAX));
69 EXPECT_TRUE(attrs.SetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, {2, 4, 6, 8, 10}));
70 EXPECT_TRUE(attrs.SetStringValue(Attributes::ATTR_TEMPLATE_ID_LIST, "iam"));
71
72 EXPECT_THAT(attrs.GetKeys(), ElementsAreArray(desired));
73 auto buff = attrs.Serialize();
74 Attributes attrs2(buff);
75 EXPECT_THAT(attrs2.GetKeys(), ElementsAreArray(desired));
76
77 bool boolValue;
78 EXPECT_TRUE(attrs2.GetBoolValue(Attributes::ATTR_RESULT_CODE, boolValue));
79 EXPECT_EQ(boolValue, true);
80
81 EXPECT_TRUE(attrs2.GetBoolValue(Attributes::ATTR_SIGNATURE, boolValue));
82 EXPECT_EQ(boolValue, false);
83
84 uint64_t u64Value;
85 EXPECT_TRUE(attrs2.GetUint64Value(Attributes::ATTR_SCHEDULE_ID, u64Value));
86 EXPECT_EQ(u64Value, UINT64_MAX);
87
88 std::vector<uint32_t> u32Vector;
89 EXPECT_TRUE(attrs2.GetUint32ArrayValue(Attributes::ATTR_REMAIN_TIMES, u32Vector));
90 EXPECT_THAT(u32Vector, ElementsAre(1, 3, 5, 7, 9));
91
92 uint32_t u32Value;
93 EXPECT_TRUE(attrs2.GetUint32Value(Attributes::ATTR_SCHEDULE_MODE, u32Value));
94 EXPECT_EQ(u32Value, UINT32_MAX);
95
96 uint16_t u16Value;
97 EXPECT_TRUE(attrs2.GetUint16Value(Attributes::ATTR_CREDENTIAL_DIGEST, u16Value));
98 EXPECT_EQ(u16Value, UINT16_MAX);
99
100 std::vector<uint64_t> u64Vector;
101 EXPECT_TRUE(attrs2.GetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, u64Vector));
102 EXPECT_THAT(u64Vector, ElementsAre(2, 4, 6, 8, 10));
103
104 std::string str;
105 EXPECT_TRUE(attrs2.GetStringValue(Attributes::ATTR_TEMPLATE_ID_LIST, str));
106 EXPECT_EQ(str, "iam");
107 }
108
109 HWTEST_F(AttributesTest, AttributesBoolValue, TestSize.Level0)
110 {
111 Attributes attrs;
112 EXPECT_TRUE(attrs.SetBoolValue(Attributes::ATTR_RESULT_CODE, true));
113 EXPECT_TRUE(attrs.SetBoolValue(Attributes::ATTR_SIGNATURE, false));
114
115 bool value1;
116 bool value2;
117 EXPECT_TRUE(attrs.GetBoolValue(Attributes::ATTR_RESULT_CODE, value1));
118 EXPECT_TRUE(attrs.GetBoolValue(Attributes::ATTR_SIGNATURE, value2));
119 EXPECT_TRUE(value1);
120 EXPECT_FALSE(value2);
121 }
122
123 HWTEST_F(AttributesTest, AttributesUint64Value, TestSize.Level0)
124 {
125 Attributes attrs;
126 uint64_t value1;
127 uint64_t value2;
128 EXPECT_FALSE(attrs.GetUint64Value(Attributes::ATTR_RESULT_CODE, value1));
129 EXPECT_FALSE(attrs.GetUint64Value(Attributes::ATTR_SIGNATURE, value2));
130
131 EXPECT_TRUE(attrs.SetUint64Value(Attributes::ATTR_RESULT_CODE, UINT32_MAX));
132 EXPECT_TRUE(attrs.SetUint64Value(Attributes::ATTR_SIGNATURE, UINT64_MAX));
133
134 EXPECT_TRUE(attrs.GetUint64Value(Attributes::ATTR_RESULT_CODE, value1));
135 EXPECT_TRUE(attrs.GetUint64Value(Attributes::ATTR_SIGNATURE, value2));
136 EXPECT_EQ(value1, UINT32_MAX);
137 EXPECT_EQ(value2, UINT64_MAX);
138 }
139
140 HWTEST_F(AttributesTest, AttributesUint32Value, TestSize.Level0)
141 {
142 Attributes attrs;
143 EXPECT_TRUE(attrs.SetUint32Value(Attributes::ATTR_RESULT_CODE, UINT16_MAX));
144 EXPECT_TRUE(attrs.SetUint32Value(Attributes::ATTR_SIGNATURE, UINT32_MAX));
145
146 uint32_t value1;
147 uint32_t value2;
148 EXPECT_TRUE(attrs.GetUint32Value(Attributes::ATTR_RESULT_CODE, value1));
149 EXPECT_TRUE(attrs.GetUint32Value(Attributes::ATTR_SIGNATURE, value2));
150 EXPECT_TRUE(value1 == UINT16_MAX);
151 EXPECT_TRUE(value2 == UINT32_MAX);
152 }
153
154 HWTEST_F(AttributesTest, AttributesUint16Value, TestSize.Level0)
155 {
156 Attributes attrs;
157 EXPECT_TRUE(attrs.SetUint16Value(Attributes::ATTR_RESULT_CODE, UINT8_MAX));
158 EXPECT_TRUE(attrs.SetUint16Value(Attributes::ATTR_SIGNATURE, UINT16_MAX));
159
160 uint16_t value1;
161 uint16_t value2;
162 EXPECT_TRUE(attrs.GetUint16Value(Attributes::ATTR_RESULT_CODE, value1));
163 EXPECT_TRUE(attrs.GetUint16Value(Attributes::ATTR_SIGNATURE, value2));
164 EXPECT_TRUE(value1 == UINT8_MAX);
165 EXPECT_TRUE(value2 == UINT16_MAX);
166 }
167
168 HWTEST_F(AttributesTest, AttributesUint8Value, TestSize.Level0)
169 {
170 Attributes attrs;
171
172 uint8_t value1;
173 uint8_t value2;
174 EXPECT_FALSE(attrs.GetUint8Value(Attributes::ATTR_RESULT_CODE, value1));
175 EXPECT_FALSE(attrs.GetUint8Value(Attributes::ATTR_SIGNATURE, value2));
176 EXPECT_TRUE(attrs.SetUint8Value(Attributes::ATTR_RESULT_CODE, 0));
177 EXPECT_TRUE(attrs.SetUint8Value(Attributes::ATTR_SIGNATURE, UINT8_MAX));
178
179 EXPECT_TRUE(attrs.GetUint8Value(Attributes::ATTR_RESULT_CODE, value1));
180 EXPECT_TRUE(attrs.GetUint8Value(Attributes::ATTR_SIGNATURE, value2));
181 EXPECT_EQ(value1, 0);
182 EXPECT_EQ(value2, UINT8_MAX);
183 }
184
185 HWTEST_F(AttributesTest, AttributesStringValue, TestSize.Level0)
186 {
187 Attributes attrs;
188 EXPECT_TRUE(attrs.SetStringValue(Attributes::ATTR_RESULT_CODE, "hello iam"));
189 EXPECT_TRUE(attrs.SetStringValue(Attributes::ATTR_SIGNATURE, ""));
190
191 std::string value1;
192 std::string value2;
193 EXPECT_TRUE(attrs.GetStringValue(Attributes::ATTR_RESULT_CODE, value1));
194 EXPECT_TRUE(attrs.GetStringValue(Attributes::ATTR_SIGNATURE, value2));
195 EXPECT_EQ(value1, "hello iam");
196 EXPECT_EQ(value2, "");
197 }
198
199 HWTEST_F(AttributesTest, AttributesUint64ByteArray, TestSize.Level0)
200 {
201 {
202 constexpr int SIZE = 8192;
203
204 Attributes attrs;
205 std::vector<uint64_t> array;
206 array.reserve(SIZE);
207 for (int i = 0; i < SIZE; i++) {
208 array.push_back(UINT64_MAX - i);
209 }
210 EXPECT_TRUE(attrs.SetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
211
212 std::vector<uint64_t> out;
213 EXPECT_TRUE(attrs.GetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
214 EXPECT_THAT(out, ElementsAreArray(array));
215 }
216
217 {
218 Attributes attrs;
219 std::vector<uint64_t> array;
220 EXPECT_TRUE(attrs.SetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
221 EXPECT_TRUE(attrs.GetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
222 EXPECT_TRUE(array.empty());
223 }
224 }
225
226 HWTEST_F(AttributesTest, AttributesUint32ByteArray, TestSize.Level0)
227 {
228 {
229 constexpr int SIZE = 8192;
230
231 Attributes attrs;
232 std::vector<uint32_t> array;
233 array.reserve(SIZE);
234 for (int i = 0; i < SIZE; i++) {
235 array.push_back(UINT32_MAX - i);
236 }
237
238 std::vector<uint32_t> out;
239 EXPECT_FALSE(attrs.GetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
240 EXPECT_TRUE(attrs.SetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
241
242 EXPECT_TRUE(attrs.GetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
243 EXPECT_THAT(out, ElementsAreArray(array));
244 }
245 {
246 Attributes attrs;
247 std::vector<uint32_t> array;
248 EXPECT_TRUE(attrs.SetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
249
250 EXPECT_TRUE(attrs.GetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
251 EXPECT_TRUE(array.empty());
252 }
253 }
254
255 HWTEST_F(AttributesTest, AttributesUint16ByteArray, TestSize.Level0)
256 {
257 {
258 constexpr int SIZE = 8192;
259
260 Attributes attrs;
261 std::vector<uint16_t> array;
262 array.reserve(SIZE);
263 for (int i = 0; i < SIZE; i++) {
264 array.push_back(UINT16_MAX - i);
265 }
266 EXPECT_TRUE(attrs.SetUint16ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
267
268 std::vector<uint16_t> out;
269 EXPECT_TRUE(attrs.GetUint16ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
270 EXPECT_THAT(out, ElementsAreArray(array));
271 }
272 {
273 Attributes attrs;
274 std::vector<uint16_t> array;
275 EXPECT_TRUE(attrs.SetUint16ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
276
277 EXPECT_TRUE(attrs.GetUint16ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
278 EXPECT_TRUE(array.empty());
279 }
280 }
281
282 HWTEST_F(AttributesTest, AttributesUint8ByteArray, TestSize.Level0)
283 {
284 {
285 constexpr int SIZE = 8192;
286
287 Attributes attrs;
288 std::vector<uint8_t> array;
289 array.reserve(SIZE);
290 for (int i = 0; i < SIZE; i++) {
291 array.push_back(i);
292 }
293 EXPECT_TRUE(attrs.SetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
294
295 std::vector<uint8_t> out;
296 EXPECT_TRUE(attrs.GetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
297 EXPECT_THAT(out, ElementsAreArray(array));
298 }
299 {
300 Attributes attrs;
301 std::vector<uint8_t> array;
302 EXPECT_TRUE(attrs.SetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
303
304 EXPECT_TRUE(attrs.GetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
305 EXPECT_TRUE(array.empty());
306 }
307 }
308
309 HWTEST_F(AttributesTest, AttributesDeserializeMismatch, TestSize.Level0)
310 {
311 const std::vector<uint8_t> raw = {0, 0, 0, 0, 1, 0, 0, 0, 1, 2, 0, 0, 0, 20, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 5, 0,
312 0, 0, 7, 0, 0, 0, 9, 0, 0, 0, 3, 0, 0, 0, 40, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0,
313 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0,
314 0, 255, 255, 255, 255, 6, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 7, 0, 0, 0, 4, 0, 0, 0,
315 105, 97, 109, 0};
316
317 Attributes attrs(raw);
318 {
319 bool value;
320 EXPECT_FALSE(attrs.GetBoolValue(Attributes::ATTR_TEMPLATE_ID_LIST, value));
321 }
322 {
323 uint16_t value;
324 EXPECT_FALSE(attrs.GetUint16Value(Attributes::ATTR_TEMPLATE_ID_LIST, value));
325 }
326 }
327
328 HWTEST_F(AttributesTest, AttributesEmptyArrays, TestSize.Level0)
329 {
330 Attributes attrs1;
331 bool value = true;
332 EXPECT_TRUE(attrs1.SetBoolValue(Attributes::ATTR_RESULT_CODE, value));
333
334 std::vector<uint64_t> u64Vector;
335 EXPECT_TRUE(attrs1.SetUint64ArrayValue(Attributes::ATTR_SCHEDULE_ID, u64Vector));
336
337 std::vector<uint32_t> u32Vector;
338 EXPECT_TRUE(attrs1.SetUint32ArrayValue(Attributes::ATTR_REMAIN_TIMES, u32Vector));
339
340 std::vector<uint16_t> u16Vector;
341 EXPECT_FALSE(attrs1.GetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, u16Vector));
342 EXPECT_TRUE(attrs1.SetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, u16Vector));
343
344 std::vector<uint8_t> u8Vector;
345 EXPECT_TRUE(attrs1.SetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, u8Vector));
346
347 auto buff = attrs1.Serialize();
348 EXPECT_FALSE(buff.empty());
349 Attributes attrs2(buff);
350 EXPECT_TRUE(attrs1.GetBoolValue(Attributes::ATTR_RESULT_CODE, value));
351 EXPECT_TRUE(value);
352
353 EXPECT_TRUE(attrs1.GetUint64ArrayValue(Attributes::ATTR_SCHEDULE_ID, u64Vector));
354 EXPECT_THAT(u64Vector, IsEmpty());
355
356 EXPECT_TRUE(attrs1.GetUint32ArrayValue(Attributes::ATTR_REMAIN_TIMES, u32Vector));
357 EXPECT_THAT(u32Vector, IsEmpty());
358
359 EXPECT_TRUE(attrs1.GetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, u16Vector));
360 EXPECT_THAT(u16Vector, IsEmpty());
361
362 EXPECT_TRUE(attrs1.GetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, u8Vector));
363 EXPECT_THAT(u8Vector, IsEmpty());
364 }
365
366 HWTEST_F(AttributesTest, AttributesCopyAndMove, TestSize.Level0)
367 {
368 EXPECT_FALSE(std::is_copy_assignable<Attributes>::value);
369 EXPECT_FALSE(std::is_copy_constructible<Attributes>::value);
370
371 const std::vector<uint8_t> raw = {0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 255,
372 255, 255, 255, 3, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 105, 97,
373 109, 0, 5, 0, 0, 0, 20, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0, 9, 0, 0, 0, 6, 0, 0, 0, 40, 0,
374 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0,
375 0, 0, 0, 0, 0};
376 Attributes attrs1(raw);
377
378 EXPECT_THAT(attrs1.Serialize(), ElementsAreArray(raw));
379
380 Attributes attrs2 = std::move(attrs1);
381
382 EXPECT_EQ(attrs1.Serialize().size(), 0U);
383 EXPECT_THAT(attrs2.Serialize(), ElementsAreArray(raw));
384 }
385
386 HWTEST_F(AttributesTest, AttributesSetAndGetAttributesArray, TestSize.Level0)
387 {
388 Attributes attrs1;
389 Attributes attrs2;
390 EXPECT_TRUE(attrs1.SetBoolValue(Attributes::ATTR_RESULT_CODE, true));
391 EXPECT_TRUE(attrs1.SetBoolValue(Attributes::ATTR_SCHEDULE_ID, false));
392 EXPECT_TRUE(attrs2.SetBoolValue(Attributes::ATTR_RESULT_CODE, true));
393 EXPECT_TRUE(attrs2.SetBoolValue(Attributes::ATTR_SCHEDULE_ID, false));
394
395 std::vector<Attributes> attrsArray;
396 attrsArray.push_back(Attributes(attrs1.Serialize()));
397 attrsArray.push_back(Attributes(attrs2.Serialize()));
398
399 Attributes setAttrs;
400 EXPECT_TRUE(setAttrs.SetAttributesArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, attrsArray));
401
402 std::vector<uint8_t> data = setAttrs.Serialize();
403 EXPECT_TRUE(data.size() > 0);
404
405 Attributes getAttrs(data);
406 std::vector<Attributes> getAttrsArray;
407 EXPECT_TRUE(getAttrs.GetAttributesArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, getAttrsArray));
408
409 ASSERT_EQ(getAttrsArray.size(), 2);
410 std::vector<uint8_t> serializedAttrs1 = attrs1.Serialize();
411 std::vector<uint8_t> serializedAttrs2 = attrs2.Serialize();
412
413 std::vector<uint8_t> serializedOutAttrs1 = getAttrsArray[0].Serialize();
414 std::vector<uint8_t> serializedOutAttrs2 = getAttrsArray[1].Serialize();
415
416 EXPECT_TRUE(serializedAttrs1 == serializedOutAttrs1);
417 EXPECT_TRUE(serializedAttrs2 == serializedOutAttrs2);
418 }
419
420 HWTEST_F(AttributesTest, AttributesSetAndGetAttributesArray01, TestSize.Level0)
421 {
422 Attributes attrs1;
423 int64_t value1 = 1;
424 int64_t value2 = 2;
425 EXPECT_EQ(attrs1.SetInt64Value(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, value2), true);
426 EXPECT_EQ(attrs1.GetInt64Value(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, value1), true);
427 EXPECT_EQ(value1, value2);
428
429 Attributes setAttrs;
430 Attributes attrs2;
431 std::vector<int32_t> array2;
432 EXPECT_EQ(setAttrs.GetInt32ArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, array2), false);
433 EXPECT_EQ(setAttrs.GetAttributesValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, attrs2), false);
434 EXPECT_EQ(setAttrs.SetAttributesValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, attrs1), true);
435 EXPECT_EQ(setAttrs.GetAttributesValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, attrs2), true);
436
437 std::vector<int32_t> array1;
438 array1.push_back(1);
439 EXPECT_EQ(setAttrs.SetInt32ArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, array1), true);
440 EXPECT_EQ(setAttrs.GetInt32ArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, array2), true);
441 }
442
443 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeUint64Value, TestSize.Level0)
444 {
445 Attributes attrs;
446 uint64_t encode_val64 = 0x0102030405060708;
447 uint64_t encode_val32 = 0x01020304;
448
449 EXPECT_TRUE(attrs.SetUint64Value(Attributes::ATTR_SIGNATURE, encode_val64));
450 EXPECT_TRUE(attrs.SetUint64Value(Attributes::ATTR_RESULT_CODE, encode_val32));
451
452 uint64_t decode_val64;
453 uint64_t decode_val32;
454
455 EXPECT_TRUE(attrs.GetUint64Value(Attributes::ATTR_SIGNATURE, decode_val64));
456 EXPECT_TRUE(attrs.GetUint64Value(Attributes::ATTR_RESULT_CODE, decode_val32));
457
458 EXPECT_EQ(encode_val64, decode_val64);
459 EXPECT_EQ(encode_val32, decode_val32);
460 }
461
462 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeUint32Value, TestSize.Level0)
463 {
464 Attributes attrs;
465 uint32_t encode_val32 = 0x01020304;
466 uint32_t encode_val16 = 0x0102;
467
468 EXPECT_TRUE(attrs.SetUint32Value(Attributes::ATTR_SIGNATURE, encode_val32));
469 EXPECT_TRUE(attrs.SetUint32Value(Attributes::ATTR_RESULT_CODE, encode_val16));
470
471 uint32_t decode_val32;
472 uint32_t decode_val16;
473
474 EXPECT_TRUE(attrs.GetUint32Value(Attributes::ATTR_SIGNATURE, decode_val32));
475 EXPECT_TRUE(attrs.GetUint32Value(Attributes::ATTR_RESULT_CODE, decode_val16));
476
477 EXPECT_EQ(encode_val32, decode_val32);
478 EXPECT_EQ(encode_val16, decode_val16);
479 }
480
481 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeUint16Value, TestSize.Level0)
482 {
483 Attributes attrs;
484 uint16_t encode_val16 = 0x0102;
485 uint16_t encode_val8 = 0x01;
486
487 EXPECT_TRUE(attrs.SetUint16Value(Attributes::ATTR_SIGNATURE, encode_val16));
488 EXPECT_TRUE(attrs.SetUint16Value(Attributes::ATTR_RESULT_CODE, encode_val8));
489
490 uint16_t decode_val16;
491 uint16_t decode_val8;
492
493 EXPECT_TRUE(attrs.GetUint16Value(Attributes::ATTR_SIGNATURE, decode_val16));
494 EXPECT_TRUE(attrs.GetUint16Value(Attributes::ATTR_RESULT_CODE, decode_val8));
495
496 EXPECT_EQ(encode_val16, decode_val16);
497 EXPECT_EQ(encode_val8, decode_val8);
498 }
499
500 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeInt64Value, TestSize.Level0)
501 {
502 Attributes attrs;
503 int64_t encode_val64 = 0x0102030405060708;
504 int64_t encode_val32 = 0x01020304;
505
506 EXPECT_TRUE(attrs.SetInt64Value(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, encode_val64));
507 EXPECT_TRUE(attrs.SetInt64Value(Attributes::ATTR_PIN_EXPIRED_INFO, encode_val32));
508
509 int64_t decode_val64;
510 int64_t decode_val32;
511
512 EXPECT_TRUE(attrs.GetInt64Value(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, decode_val64));
513 EXPECT_TRUE(attrs.GetInt64Value(Attributes::ATTR_PIN_EXPIRED_INFO, decode_val32));
514
515 EXPECT_EQ(encode_val64, decode_val64);
516 EXPECT_EQ(encode_val32, decode_val32);
517 }
518
519 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeInt32Value, TestSize.Level0)
520 {
521 Attributes attrs;
522 int32_t encode_val32 = 0x01020304;
523 int32_t encode_val16 = 0x0102;
524
525 EXPECT_TRUE(attrs.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, encode_val32));
526 EXPECT_TRUE(attrs.SetInt32Value(Attributes::ATTR_TIP_INFO, encode_val16));
527
528 int32_t decode_val32;
529 int32_t decode_val16;
530
531 EXPECT_TRUE(attrs.GetInt32Value(Attributes::ATTR_REMAIN_TIMES, decode_val32));
532 EXPECT_TRUE(attrs.GetInt32Value(Attributes::ATTR_TIP_INFO, decode_val16));
533
534 EXPECT_EQ(encode_val32, decode_val32);
535 EXPECT_EQ(encode_val16, decode_val16);
536 }
537
538 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeUint64Array, TestSize.Level0)
539 {
540 {
541 Attributes attrs_outsize;
542 constexpr int ENCODE_ARRAY_OUT_SIZE = 81921;
543 std::vector<uint64_t> encode_outsize_array;
544 encode_outsize_array.reserve(ENCODE_ARRAY_OUT_SIZE);
545 for (int i = 0; i < ENCODE_ARRAY_OUT_SIZE; i++) {
546 encode_outsize_array.push_back(UINT64_MAX - i);
547 }
548 EXPECT_FALSE(attrs_outsize.SetUint64ArrayValue(Attributes::ATTR_LOCKED_TEMPLATES, encode_outsize_array));
549 }
550
551 {
552 Attributes attrs_empty;
553 std::vector<uint64_t> encode_empty_array;
554 std::vector<uint64_t> decode_empty_array;
555 EXPECT_TRUE(attrs_empty.SetUint64ArrayValue(Attributes::ATTR_LOCKED_TEMPLATES, encode_empty_array));
556 EXPECT_TRUE(attrs_empty.GetUint64ArrayValue(Attributes::ATTR_LOCKED_TEMPLATES, decode_empty_array));
557 EXPECT_THAT(encode_empty_array, decode_empty_array);
558 }
559
560 {
561 Attributes attrs;
562 constexpr int ARRAY_SIZE = 1024;
563 std::vector<uint64_t> encode_array;
564 std::vector<uint64_t> decode_array;
565 encode_array.reserve(ARRAY_SIZE);
566 for (int i = 0; i < ARRAY_SIZE; i++) {
567 encode_array.push_back(UINT64_MAX - i);
568 }
569 EXPECT_TRUE(attrs.SetUint64ArrayValue(Attributes::ATTR_LOCKED_TEMPLATES, encode_array));
570 EXPECT_TRUE(attrs.GetUint64ArrayValue(Attributes::ATTR_LOCKED_TEMPLATES, decode_array));
571 EXPECT_THAT(encode_array, decode_array);
572 }
573 }
574
575 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeUint32Array, TestSize.Level0)
576 {
577 {
578 Attributes attrs_outsize;
579 constexpr int ENCODE_ARRAY_OUT_SIZE = 81921;
580 std::vector<uint32_t> encode_outsize_array;
581 encode_outsize_array.reserve(ENCODE_ARRAY_OUT_SIZE);
582 for (int i = 0; i < ENCODE_ARRAY_OUT_SIZE; i++) {
583 encode_outsize_array.push_back(UINT32_MAX - i);
584 }
585 EXPECT_FALSE(attrs_outsize.SetUint32ArrayValue(Attributes::ATTR_KEY_LIST, encode_outsize_array));
586 }
587
588 {
589 Attributes attrs_empty;
590 std::vector<uint32_t> encode_empty_array;
591 std::vector<uint32_t> decode_empty_array;
592 EXPECT_TRUE(attrs_empty.SetUint32ArrayValue(Attributes::ATTR_KEY_LIST, encode_empty_array));
593 EXPECT_TRUE(attrs_empty.GetUint32ArrayValue(Attributes::ATTR_KEY_LIST, decode_empty_array));
594 EXPECT_THAT(encode_empty_array, decode_empty_array);
595 }
596
597 {
598 Attributes attrs;
599 constexpr int ARRAY_SIZE = 1024;
600 std::vector<uint32_t> encode_array;
601 std::vector<uint32_t> decode_array;
602 encode_array.reserve(ARRAY_SIZE);
603 for (int i = 0; i < ARRAY_SIZE; i++) {
604 encode_array.push_back(UINT32_MAX - i);
605 }
606 EXPECT_TRUE(attrs.SetUint32ArrayValue(Attributes::ATTR_KEY_LIST, encode_array));
607 EXPECT_TRUE(attrs.GetUint32ArrayValue(Attributes::ATTR_KEY_LIST, decode_array));
608 EXPECT_THAT(encode_array, decode_array);
609 }
610 }
611
612 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeUint16Array, TestSize.Level0)
613 {
614 {
615 Attributes attrs_outsize;
616 constexpr int ENCODE_ARRAY_OUT_SIZE = 81921;
617 std::vector<uint16_t> encode_outsize_array;
618 encode_outsize_array.reserve(ENCODE_ARRAY_OUT_SIZE);
619 for (int i = 0; i < ENCODE_ARRAY_OUT_SIZE; i++) {
620 encode_outsize_array.push_back(UINT16_MAX - i);
621 }
622 EXPECT_FALSE(attrs_outsize.SetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, encode_outsize_array));
623 }
624
625 {
626 Attributes attrs_empty;
627 std::vector<uint16_t> encode_empty_array;
628 std::vector<uint16_t> decode_empty_array;
629 EXPECT_TRUE(attrs_empty.SetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, encode_empty_array));
630 EXPECT_TRUE(attrs_empty.GetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, decode_empty_array));
631 EXPECT_THAT(encode_empty_array, decode_empty_array);
632 }
633
634 {
635 Attributes attrs;
636 constexpr int ARRAY_SIZE = 1024;
637 std::vector<uint16_t> encode_array;
638 std::vector<uint16_t> decode_array;
639 encode_array.reserve(ARRAY_SIZE);
640 for (int i = 0; i < ARRAY_SIZE; i++) {
641 encode_array.push_back(UINT16_MAX - i);
642 }
643 EXPECT_TRUE(attrs.SetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, encode_array));
644 EXPECT_TRUE(attrs.GetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, decode_array));
645 EXPECT_THAT(encode_array, decode_array);
646 }
647 }
648
649 HWTEST_F(AttributesTest, AttributesEncodeAndDecodeInt32Array, TestSize.Level0)
650 {
651 {
652 Attributes attrs_outsize;
653 constexpr int ENCODE_ARRAY_OUT_SIZE = 81921;
654 std::vector<int32_t> encode_outsize_array;
655 encode_outsize_array.reserve(ENCODE_ARRAY_OUT_SIZE);
656 for (int i = 0; i < ENCODE_ARRAY_OUT_SIZE; i++) {
657 encode_outsize_array.push_back(INT32_MAX - i);
658 }
659 EXPECT_FALSE(attrs_outsize.SetInt32ArrayValue(Attributes::ATTR_AUTH_TYPES, encode_outsize_array));
660 }
661
662 {
663 Attributes attrs_empty;
664 std::vector<int32_t> encode_empty_array;
665 std::vector<int32_t> decode_empty_array;
666 EXPECT_TRUE(attrs_empty.SetInt32ArrayValue(Attributes::ATTR_AUTH_TYPES, encode_empty_array));
667 EXPECT_TRUE(attrs_empty.GetInt32ArrayValue(Attributes::ATTR_AUTH_TYPES, decode_empty_array));
668 EXPECT_THAT(encode_empty_array, decode_empty_array);
669 }
670
671 {
672 Attributes attrs;
673 constexpr int ARRAY_SIZE = 1024;
674 std::vector<int32_t> encode_array;
675 std::vector<int32_t> decode_array;
676 encode_array.reserve(ARRAY_SIZE);
677 for (int i = 0; i < ARRAY_SIZE; i++) {
678 encode_array.push_back(INT32_MAX - i);
679 }
680 EXPECT_TRUE(attrs.SetInt32ArrayValue(Attributes::ATTR_AUTH_TYPES, encode_array));
681 EXPECT_TRUE(attrs.GetInt32ArrayValue(Attributes::ATTR_AUTH_TYPES, decode_array));
682 EXPECT_THAT(encode_array, decode_array);
683 }
684 }
685
686 HWTEST_F(AttributesTest, AttributesSerializeAndDeserialize01, TestSize.Level0)
687 {
688 const uint64_t U64_VAL = 0x0102030405060708;
689 const uint32_t U32_VAL = 0x01020304;
690 const uint16_t U16_VAL = 0x0102;
691 const int32_t I32_VAL = 0x01020304;
692 Attributes attrs_serial;
693 EXPECT_TRUE(attrs_serial.SetUint64Value(Attributes::ATTR_SCHEDULE_ID, U64_VAL));
694 EXPECT_TRUE(attrs_serial.SetUint32Value(Attributes::ATTR_SCHEDULE_MODE, U32_VAL));
695 EXPECT_TRUE(attrs_serial.SetUint16Value(Attributes::ATTR_CREDENTIAL_DIGEST, U16_VAL));
696 EXPECT_TRUE(attrs_serial.SetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME,
697 {U64_VAL, U64_VAL, U64_VAL, U64_VAL, U64_VAL}));
698 EXPECT_TRUE(attrs_serial.SetUint32ArrayValue(Attributes::ATTR_KEY_LIST,
699 {U32_VAL, U32_VAL, U32_VAL, U32_VAL, U32_VAL}));
700 EXPECT_TRUE(attrs_serial.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, I32_VAL));
701 EXPECT_TRUE(attrs_serial.SetInt32ArrayValue(Attributes::ATTR_AUTH_TYPES,
702 {I32_VAL, I32_VAL, I32_VAL, I32_VAL, I32_VAL}));
703 int64_t test_int64_val = 100;
704 EXPECT_TRUE(attrs_serial.SetInt64Value(Attributes::ATTR_PIN_EXPIRED_INFO, test_int64_val));
705 auto buffer = attrs_serial.Serialize();
706
707 Attributes attrs_deserial(buffer);
708 uint64_t u64_value;
709 EXPECT_TRUE(attrs_deserial.GetUint64Value(Attributes::ATTR_SCHEDULE_ID, u64_value));
710 EXPECT_EQ(u64_value, U64_VAL);
711 uint32_t u32_value;
712 EXPECT_TRUE(attrs_deserial.GetUint32Value(Attributes::ATTR_SCHEDULE_MODE, u32_value));
713 EXPECT_EQ(u32_value, U32_VAL);
714 uint16_t u16_value;
715 EXPECT_TRUE(attrs_deserial.GetUint16Value(Attributes::ATTR_CREDENTIAL_DIGEST, u16_value));
716 EXPECT_EQ(u16_value, U16_VAL);
717 std::vector<uint64_t> u64_vector;
718 EXPECT_TRUE(attrs_deserial.GetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, u64_vector));
719 EXPECT_THAT(u64_vector, ElementsAre(U64_VAL, U64_VAL, U64_VAL, U64_VAL, U64_VAL));
720 std::vector<uint32_t> u32_vector;
721 EXPECT_TRUE(attrs_deserial.GetUint32ArrayValue(Attributes::ATTR_KEY_LIST, u32_vector));
722 EXPECT_THAT(u32_vector, ElementsAre(U32_VAL, U32_VAL, U32_VAL, U32_VAL, U32_VAL));
723 int32_t int32_value;
724 EXPECT_TRUE(attrs_deserial.GetInt32Value(Attributes::ATTR_REMAIN_TIMES, int32_value));
725 EXPECT_EQ(int32_value, I32_VAL);
726 std::vector<int32_t> int32_vector;
727 EXPECT_TRUE(attrs_deserial.GetInt32ArrayValue(Attributes::ATTR_AUTH_TYPES, int32_vector));
728 EXPECT_THAT(int32_vector, ElementsAre(I32_VAL, I32_VAL, I32_VAL, I32_VAL, I32_VAL));
729 int64_t int64_value;
730 EXPECT_TRUE(attrs_deserial.GetInt64Value(Attributes::ATTR_PIN_EXPIRED_INFO, int64_value));
731 EXPECT_EQ(int64_value, 100);
732 }
733
734 HWTEST_F(AttributesTest, AttributesSerializeAndDeserialize02, TestSize.Level0)
735 {
736 const uint32_t U32_VAL = 0x01020304;
737 const uint8_t U8_VAL = 0x01;
738 Attributes attrs_serial;
739 EXPECT_TRUE(attrs_serial.SetBoolValue(Attributes::ATTR_END_AFTER_FIRST_FAIL, true));
740 EXPECT_TRUE(attrs_serial.SetBoolValue(Attributes::ATTR_MSG_ACK, false));
741 EXPECT_TRUE(attrs_serial.SetUint32Value(Attributes::ATTR_SCHEDULE_MODE, U32_VAL));
742 EXPECT_TRUE(attrs_serial.SetUint32ArrayValue(Attributes::ATTR_KEY_LIST,
743 {U32_VAL, U32_VAL, U32_VAL, U32_VAL, U32_VAL}));
744 EXPECT_TRUE(attrs_serial.SetStringValue(Attributes::ATTR_CALLER_NAME, "iam_unit_test"));
745 EXPECT_TRUE(attrs_serial.SetUint8Value(Attributes::ATTR_ROOT, U8_VAL));
746 EXPECT_TRUE(attrs_serial.SetUint8ArrayValue(Attributes::ATTR_DATA,
747 {U8_VAL, U8_VAL, U8_VAL, U8_VAL, U8_VAL}));
748 auto buffer = attrs_serial.Serialize();
749
750 Attributes attrs_deserial(buffer);
751 bool bool_valt;
752 EXPECT_TRUE(attrs_deserial.GetBoolValue(Attributes::ATTR_END_AFTER_FIRST_FAIL, bool_valt));
753 EXPECT_EQ(bool_valt, true);
754
755 bool bool_valf;
756 EXPECT_TRUE(attrs_deserial.GetBoolValue(Attributes::ATTR_MSG_ACK, bool_valf));
757 EXPECT_EQ(bool_valf, false);
758
759 uint32_t u32_value;
760 EXPECT_TRUE(attrs_deserial.GetUint32Value(Attributes::ATTR_SCHEDULE_MODE, u32_value));
761 EXPECT_EQ(u32_value, U32_VAL);
762
763 std::vector<uint32_t> u32_vector;
764 EXPECT_TRUE(attrs_deserial.GetUint32ArrayValue(Attributes::ATTR_KEY_LIST, u32_vector));
765 EXPECT_THAT(u32_vector, ElementsAre(U32_VAL, U32_VAL, U32_VAL, U32_VAL, U32_VAL));
766
767 std::string str_value;
768 EXPECT_TRUE(attrs_deserial.GetStringValue(Attributes::ATTR_CALLER_NAME, str_value));
769 EXPECT_EQ(str_value, "iam_unit_test");
770
771 uint8_t u8_val;
772 EXPECT_TRUE(attrs_deserial.GetUint8Value(Attributes::ATTR_ROOT, u8_val));
773 EXPECT_EQ(u8_val, U8_VAL);
774
775 std::vector<uint8_t> u8_vector;
776 EXPECT_TRUE(attrs_deserial.GetUint8ArrayValue(Attributes::ATTR_DATA, u8_vector));
777 EXPECT_THAT(u8_vector, ElementsAre(U8_VAL, U8_VAL, U8_VAL, U8_VAL, U8_VAL));
778 }
779
780 HWTEST_F(AttributesTest, AttributesRawSerializeTest01, TestSize.Level0)
781 {
782 std::vector<uint8_t> raw = {160, 134, 1, 0, 1, 0, 0, 0, 255, 175, 134,
783 1, 0, 14, 0, 0, 0, 105, 97, 109, 95, 117, 110, 105, 116, 95, 116,
784 101, 115, 116, 0, 180, 134, 1, 0, 5, 0, 0, 0, 255, 255,
785 255, 255, 255, 182, 134, 1, 0, 4, 0, 0, 0, 255, 255, 255,
786 255, 197, 134, 1, 0, 20, 0, 0, 0, 255, 255, 255, 255, 255,
787 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
788 255, 255, 198, 134, 1, 0, 1, 0, 0, 0, 1, 213, 134, 1, 0, 1,
789 0, 0, 0, 0};
790
791 Attributes attrs(raw);
792 std::vector<uint8_t> buffer = attrs.Serialize();
793 for (int i = 0; i < buffer.size(); i++) {
794 EXPECT_THAT(raw[i], buffer[i]);
795 }
796 }
797
798 HWTEST_F(AttributesTest, AttributesRawSerializeTest03, TestSize.Level0)
799 {
800 std::vector<uint8_t> raw = {169, 134, 1, 0, 4, 0, 0, 0, 255, 255, 255,
801 127, 170, 134, 1, 0, 40, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255,
802 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
803 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
804 255, 255, 255, 255, 255, 177, 134, 1, 0,
805 8, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 182,
806 134, 1, 0, 4, 0, 0, 0, 255, 255, 255, 255, 197,
807 134, 1, 0, 20, 0, 0, 0, 255, 255, 255, 255, 255,
808 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
809 255, 255, 255, 255, 210, 134, 1, 0, 2, 0, 0, 0, 255,
810 255, 234, 134, 1, 0, 20, 0, 0, 0, 255, 255, 255,
811 127, 255, 255, 255, 127, 255, 255, 255,
812 127, 255, 255, 255, 127, 255, 255, 255,
813 127, 243, 134, 1, 0, 8, 0, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0};
814
815 Attributes attrs(raw);
816 std::vector<uint8_t> buffer = attrs.Serialize();
817 for (int i = 0; i < buffer.size(); i++) {
818 EXPECT_THAT(raw[i], buffer[i]);
819 }
820 }
821
822 } // namespace UserAuth
823 } // namespace UserIam
824 } // namespace OHOS
825