1 /*
2  * Copyright (c) 2021 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 <cstring>
17 #include <unistd.h>
18 
19 #include "gtest/gtest.h"
20 
21 #include "client_executor/include/i_aie_client.inl"
22 #include "protocol/struct_definition/aie_info_define.h"
23 #include "service_dead_cb.h"
24 #include "utils/log/aie_log.h"
25 
26 using namespace OHOS::AI;
27 using namespace testing::ext;
28 
29 namespace {
30     const char * const INPUT_CHARACTER = "inputData";
31     const char * const CONFIG_DESCRIPTION = "config information";
32     const long long CLIENT_INFO_VERSION = 1;
33     const int CLIENT_ID = -1;
34     const int SESSION_ID = -1;
35     const long long ALGORITHM_INFO_CLIENT_VERSION = 2;
36     const int ALGORITHM_TYPE_SYNC = 0;
37     const int ALGORITHM_TYPE_ASYNC = 1;
38     const long long ALGORITHM_VERSION = 1;
39     const int OPERATE_ID = 2;
40     const int REQUEST_ID = 3;
41 }
42 
43 class DestroyFunctionTest : public testing::Test {
44 public:
45     // SetUpTestCase:The preset action of the test suite is executed before the first TestCase
SetUpTestCase()46     static void SetUpTestCase() {};
47 
48     // TearDownTestCase:The test suite cleanup action is executed after the last TestCase
TearDownTestCase()49     static void TearDownTestCase() {};
50 
51     // SetUp:Execute before each test case
SetUp()52     void SetUp() {};
53 
54     // TearDown:Execute after each test case
TearDown()55     void TearDown() {};
56 };
57 
58 class ClientCallback : public IClientCb {
59 public:
60     ClientCallback() = default;
61     ~ClientCallback() override = default;
OnResult(const DataInfo & result,int resultCode,int requestId)62     void OnResult(const DataInfo &result, int resultCode, int requestId) override
63     {
64         HILOGI("[Test]TestAieClientDestroy001 OnResult resultCode[%d],"\
65             "requestId[%d], resultData[%s], resultLength[%d].",
66             resultCode, requestId, result.data, result.length);
67     }
68 };
69 
70 /**
71  * @tc.name: TestAieClientDestroy001
72  * @tc.desc: Test the execution of destroying interface immediately after initializing ai server.
73  * @tc.type: FUNC
74  * @tc.require: AR000F77NL
75  */
76 HWTEST_F(DestroyFunctionTest, TestAieClientDestroy001, TestSize.Level0)
77 {
78     HILOGI("[Test]TestAieClientDestroy001.");
79 
80     ConfigInfo configInfo {.description = CONFIG_DESCRIPTION};
81 
82     const char *str = INPUT_CHARACTER;
83     char *inputData = const_cast<char*>(str);
84     int len = strlen(str) + 1;
85 
86     ClientInfo clientInfo = {
87         .clientVersion = CLIENT_INFO_VERSION,
88         .clientId = CLIENT_ID,
89         .sessionId = SESSION_ID,
90         .serverUid = INVALID_UID,
91         .clientUid = INVALID_UID,
92         .extendLen = len,
93         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
94     };
95 
96     AlgorithmInfo algoInfo = {
97         .clientVersion = ALGORITHM_INFO_CLIENT_VERSION,
98         .isAsync = false,
99         .algorithmType = ALGORITHM_TYPE_SYNC,
100         .algorithmVersion = ALGORITHM_VERSION,
101         .isCloud = true,
102         .operateId = OPERATE_ID,
103         .requestId = REQUEST_ID,
104         .extendLen = len,
105         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
106     };
107 
108     ServiceDeadCb deadCb = ServiceDeadCb();
109     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &deadCb);
110     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
111     ASSERT_TRUE(clientInfo.clientId > 0);
112 
113     int resultCodeDestroy = AieClientDestroy(clientInfo);
114     ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
115     ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
116 }
117 
118 /**
119  * @tc.name: TestAieClientDestroy002
120  * @tc.desc: Test the execution of destroying interface, after initializing, preparing and synchronous processing.
121  * @tc.type: FUNC
122  * @tc.require: AR000F77NL
123  */
124 HWTEST_F(DestroyFunctionTest, TestAieClientDestroy002, TestSize.Level0)
125 {
126     HILOGI("[Test]TestAieClientDestroy002.");
127 
128     ConfigInfo configInfo {.description = CONFIG_DESCRIPTION};
129 
130     const char *str = INPUT_CHARACTER;
131     char *inputData = const_cast<char*>(str);
132     int len = strlen(str) + 1;
133 
134     ClientInfo clientInfo = {
135         .clientVersion = CLIENT_INFO_VERSION,
136         .clientId = CLIENT_ID,
137         .sessionId = SESSION_ID,
138         .serverUid = INVALID_UID,
139         .clientUid = INVALID_UID,
140         .extendLen = len,
141         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
142     };
143 
144     AlgorithmInfo algoInfo = {
145         .clientVersion = ALGORITHM_INFO_CLIENT_VERSION,
146         .isAsync = false,
147         .algorithmType = ALGORITHM_TYPE_SYNC,
148         .algorithmVersion = ALGORITHM_VERSION,
149         .isCloud = true,
150         .operateId = OPERATE_ID,
151         .requestId = REQUEST_ID,
152         .extendLen = len,
153         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
154     };
155 
156     DataInfo inputInfo = {
157         .data = reinterpret_cast<unsigned char*>(inputData),
158         .length = len,
159     };
160 
161     ServiceDeadCb cb = ServiceDeadCb();
162     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
163     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
164     ASSERT_TRUE(clientInfo.clientId > 0);
165 
166     IClientCb *callback = nullptr;
167     DataInfo outputInfo;
168     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, callback);
169     ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
170     ASSERT_TRUE(clientInfo.clientId > 0);
171 
172     int resultCodeSyncProcess = AieClientSyncProcess(clientInfo, algoInfo, inputInfo, outputInfo);
173     ASSERT_EQ(resultCodeSyncProcess, RETCODE_SUCCESS);
174     ASSERT_TRUE(clientInfo.clientId > 0);
175 
176     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
177     ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
178     ASSERT_TRUE(clientInfo.clientId > 0);
179 
180     int resultCodeDestroy = AieClientDestroy(clientInfo);
181     ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
182     ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
183 }
184 
185 /**
186  * @tc.name: TestAieClientDestroy003
187  * @tc.desc: Test the execution of destroying interface, after initializing, preparing and asynchronous processing.
188  * @tc.type: FUNC
189  * @tc.require: AR000F77NL
190  */
191 HWTEST_F(DestroyFunctionTest, TestAieClientDestroy003, TestSize.Level0)
192 {
193     HILOGI("[Test]TestAieClientDestroy003.");
194 
195     ConfigInfo configInfo {.description = CONFIG_DESCRIPTION};
196 
197     const char *str = INPUT_CHARACTER;
198     char *inputData = const_cast<char*>(str);
199     int len = strlen(str) + 1;
200 
201     ClientInfo clientInfo = {
202         .clientVersion = CLIENT_INFO_VERSION,
203         .clientId = CLIENT_ID,
204         .sessionId = SESSION_ID,
205         .serverUid = INVALID_UID,
206         .clientUid = INVALID_UID,
207         .extendLen = len,
208         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
209     };
210 
211     AlgorithmInfo algoInfo = {
212         .clientVersion = ALGORITHM_INFO_CLIENT_VERSION,
213         .isAsync = true,
214         .algorithmType = ALGORITHM_TYPE_ASYNC,
215         .algorithmVersion = ALGORITHM_VERSION,
216         .isCloud = true,
217         .operateId = OPERATE_ID,
218         .requestId = REQUEST_ID,
219         .extendLen = len,
220         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
221     };
222 
223     DataInfo inputInfo = {
224         .data = reinterpret_cast<unsigned char*>(inputData),
225         .length = len,
226     };
227 
228     ServiceDeadCb cb = ServiceDeadCb();
229     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
230     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
231     ASSERT_TRUE(clientInfo.clientId > 0);
232 
233     ClientCallback callback = ClientCallback();
234     DataInfo outputInfo;
235     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, &callback);
236     ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
237     ASSERT_TRUE(clientInfo.clientId > 0);
238 
239     int resultCodeAsyncProcess = AieClientAsyncProcess(clientInfo, algoInfo, inputInfo);
240     ASSERT_EQ(resultCodeAsyncProcess, RETCODE_SUCCESS);
241     ASSERT_TRUE(clientInfo.clientId > 0);
242 
243     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
244     ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
245     ASSERT_TRUE(clientInfo.clientId > 0);
246 
247     int resultCodeDestroy = AieClientDestroy(clientInfo);
248     ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
249     ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
250 }
251 
252 /**
253  * @tc.name: TestAieClientDestroy004
254  * @tc.desc: Test the execution of destroying interface, on the condition that dead callback is nullptr
255  *           and not registered.
256  * @tc.type: FUNC
257  * @tc.require: AR000F77NL
258  */
259 HWTEST_F(DestroyFunctionTest, TestAieClientDestroy004, TestSize.Level0)
260 {
261     HILOGI("[Test]TestAieClientDestroy004.");
262 
263     ConfigInfo configInfo {.description = CONFIG_DESCRIPTION};
264 
265     const char *str = INPUT_CHARACTER;
266     char *inputData = const_cast<char*>(str);
267     int len = strlen(str) + 1;
268 
269     ClientInfo clientInfo = {
270         .clientVersion = CLIENT_INFO_VERSION,
271         .clientId = CLIENT_ID,
272         .sessionId = SESSION_ID,
273         .serverUid = INVALID_UID,
274         .clientUid = INVALID_UID,
275         .extendLen = len,
276         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
277     };
278 
279     AlgorithmInfo algoInfo = {
280         .clientVersion = ALGORITHM_INFO_CLIENT_VERSION,
281         .isAsync = true,
282         .algorithmType = ALGORITHM_TYPE_ASYNC,
283         .algorithmVersion = ALGORITHM_VERSION,
284         .isCloud = true,
285         .operateId = OPERATE_ID,
286         .requestId = REQUEST_ID,
287         .extendLen = len,
288         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
289     };
290 
291     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, nullptr);
292     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
293     ASSERT_TRUE(clientInfo.clientId > 0);
294 
295     int resultCodeDestroy = AieClientDestroy(clientInfo);
296     ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
297     ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
298 }
299 
300 /**
301  * @tc.name: TestAieClientDestroy005
302  * @tc.desc: Test the execution of destroying interface, after initializing, preparing.
303  * @tc.type: FUNC
304  * @tc.require: AR000F77NL
305  */
306 HWTEST_F(DestroyFunctionTest, TestAieClientDestroy005, TestSize.Level0)
307 {
308     HILOGI("[Test]TestAieClientDestroy005.");
309 
310     ConfigInfo configInfo {.description = CONFIG_DESCRIPTION};
311 
312     const char *str = INPUT_CHARACTER;
313     char *inputData = const_cast<char*>(str);
314     int len = strlen(str) + 1;
315 
316     ClientInfo clientInfo = {
317         .clientVersion = CLIENT_INFO_VERSION,
318         .clientId = CLIENT_ID,
319         .sessionId = SESSION_ID,
320         .serverUid = INVALID_UID,
321         .clientUid = INVALID_UID,
322         .extendLen = len,
323         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
324     };
325 
326     AlgorithmInfo algoInfo = {
327         .clientVersion = ALGORITHM_INFO_CLIENT_VERSION,
328         .isAsync = false,
329         .algorithmType = ALGORITHM_TYPE_SYNC,
330         .algorithmVersion = ALGORITHM_VERSION,
331         .isCloud = true,
332         .operateId = OPERATE_ID,
333         .requestId = REQUEST_ID,
334         .extendLen = len,
335         .extendMsg = reinterpret_cast<unsigned char*>(inputData),
336     };
337 
338     DataInfo inputInfo = {
339         .data = reinterpret_cast<unsigned char*>(inputData),
340         .length = len,
341     };
342 
343     ServiceDeadCb cb = ServiceDeadCb();
344     int resultCodeInit = AieClientInit(configInfo, clientInfo, algoInfo, &cb);
345     ASSERT_EQ(resultCodeInit, RETCODE_SUCCESS);
346     ASSERT_TRUE(clientInfo.clientId > 0);
347 
348     IClientCb *callback = nullptr;
349     DataInfo outputInfo;
350     int resultCodePrepare = AieClientPrepare(clientInfo, algoInfo, inputInfo, outputInfo, callback);
351     ASSERT_EQ(resultCodePrepare, RETCODE_SUCCESS);
352     ASSERT_TRUE(clientInfo.clientId > 0);
353 
354     int resultCodeRelease = AieClientRelease(clientInfo, algoInfo, inputInfo);
355     ASSERT_EQ(resultCodeRelease, RETCODE_SUCCESS);
356     ASSERT_TRUE(clientInfo.clientId > 0);
357 
358     int resultCodeDestroy = AieClientDestroy(clientInfo);
359     ASSERT_EQ(resultCodeDestroy, RETCODE_SUCCESS);
360     ASSERT_EQ(clientInfo.clientId, INVALID_SESSION_ID);
361 }
362