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 "iam_hat_test.h"
17 
18 #include <cstdint>
19 #include <string>
20 #include <vector>
21 
22 #include "parcel.h"
23 #include "securec.h"
24 
25 using namespace std;
26 
27 
28 #define LOG_LABEL UserIam::Common::LABEL_IAM_COMMON
29 
30 namespace OHOS {
31     namespace UserIam {
32         namespace Common {
33             namespace {
34                 constexpr int32_t MAX_DATA_LEN = 200;
FillTestBuffer(Parcel &parcel, void *p, uint32_t len)35                 void FillTestBuffer(Parcel &parcel, void *p, uint32_t len)
36                 {
37                     if (len == 0) {
38                         return;
39                     }
40 
41                     auto buffer = parcel.ReadBuffer(len);
42                     if (buffer == nullptr) {
43                         cout << "ReadBuffer len " << len << " fail!" << endl;
44                         return;
45                     }
46 
47                     if (memcpy_s(p, len, buffer, len) != EOK) {
48                         cout << "memcpy_s fail" << endl;
49                         return;
50                     }
51 
52                     return;
53                 }
54             } // namespace
55 
FillTestUint8Vector(Parcel &parcel, std::vector<uint8_t> &data)56             void FillTestUint8Vector(Parcel &parcel, std::vector<uint8_t> &data)
57             {
58                 uint32_t len = parcel.ReadUint32() % MAX_DATA_LEN;
59                 uint32_t memLen = len * sizeof(uint8_t);
60                 data.resize(len);
61                 FillTestBuffer(parcel, static_cast<void *>(&data[0]), memLen);
62                 cout << "fill vector len " << len << "ok" << endl;
63             }
64 
FillTestInt8Vector(Parcel &parcel, std::vector<int8_t> &data)65             void FillTestInt8Vector(Parcel &parcel, std::vector<int8_t> &data)
66             {
67                 uint32_t len = parcel.ReadUint32() % MAX_DATA_LEN;
68                 uint32_t memLen = len * sizeof(int8_t);
69                 data.resize(len);
70                 FillTestBuffer(parcel, static_cast<void *>(&data[0]), memLen);
71                 cout << "fill vector len " << len << "ok" << endl;
72             }
73 
FillTestUint32Vector(Parcel &parcel, std::vector<uint32_t> &data)74             void FillTestUint32Vector(Parcel &parcel, std::vector<uint32_t> &data)
75             {
76                 uint32_t len = parcel.ReadUint32() % MAX_DATA_LEN;
77                 uint32_t memLen = len * sizeof(uint32_t);
78                 data.resize(len);
79                 FillTestBuffer(parcel, static_cast<void *>(&data[0]), memLen);
80                 cout << "fill vector len " << len << "ok" << endl;
81             }
82 
FillTestInt32Vector(Parcel &parcel, std::vector<int32_t> &data)83             void FillTestInt32Vector(Parcel &parcel, std::vector<int32_t> &data)
84             {
85                 uint32_t len = parcel.ReadUint32() % MAX_DATA_LEN;
86                 uint32_t memLen = len * sizeof(int32_t);
87                 data.resize(len);
88                 FillTestBuffer(parcel, static_cast<void *>(&data[0]), memLen);
89                 cout << "fill vector len " << len << "ok" << endl;
90             }
91 
FillTestUint64Vector(Parcel &parcel, std::vector<uint64_t> &data)92             void FillTestUint64Vector(Parcel &parcel, std::vector<uint64_t> &data)
93             {
94                 uint32_t len = parcel.ReadUint32() % MAX_DATA_LEN;
95                 uint32_t memLen = len * sizeof(uint64_t);
96                 data.resize(len);
97                 FillTestBuffer(parcel, static_cast<void *>(&data[0]), memLen);
98                 cout << "fill vector len " << len << "ok" << endl;
99             }
100 
FillTestString(Parcel &parcel, std::string &str)101             void FillTestString(Parcel &parcel, std::string &str)
102             {
103                 uint32_t len = parcel.ReadUint32() % MAX_DATA_LEN + 1;
104                 uint32_t memLen = len * sizeof(char);
105                 std::vector<char> data(len, 0);
106                 FillTestBuffer(parcel, static_cast<void *>(&data[0]), memLen - 1);
107                 str = std::string(&data[0]);
108                 cout << "fill string len " << (len - 1) << " ok" << endl;
109             }
110         } // namespace Common
111     }     // namespace UserIam
112 } // namespace OHOS