• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2022 Huawei Technologies Co., Ltd.
3  * Licensed under the Mulan PSL v2.
4  * You can use this software according to the terms and conditions of the Mulan PSL v2.
5  * You may obtain a copy of Mulan PSL v2 at:
6  * http://license.coscl.org.cn/MulanPSL2
7  * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
8  * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
9  * PURPOSE.
10  * See the Mulan PSL v2 for more details.
11  */
12 
13 #include <common_test.h>
14 #include <gtest/gtest.h>
15 #include <securec.h>
16 #include <session_mgr/client_session_mgr.h>
17 #include <tee_client_api.h>
18 #include <tee_client_type.h>
19 #include <test_defines.h>
20 #include <test_log.h>
21 #include <test_tcf_cmdid.h>
22 
23 using namespace testing::ext;
24 
25 static char g_teeOutput[] = "TEEMEM_OUTPUT";
26 static char g_teeInout[] = "the param is TEEMEM_INOUT";
27 static uint32_t g_teeOutputLen;
28 static uint32_t g_teeInoutLen;
29 
30 /**
31  * @testcase.name      : TEE_OpenTASession_With_Success
32  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA
33  * @testcase.expect    : return TEEC_SUCCESS
34  */
35 TEE_TEST(TeeTCF2TA2TATest, TEE_OpenTASession_With_Success, Function | MediumTest | Level0)
36 {
37     TEEC_Result ret;
38     uint32_t ta2taSession;
39     uint32_t origin = 0;
40     TestData value = { 0 };
41     value.caseId = 0;
42     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
43     g_teeInoutLen = strlen(g_teeInout) + 1;
44 
45     value.inBufferLen = BIG_SIZE;
46     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
47     ASSERT_EQ(ret, TEEC_SUCCESS);
48     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
49     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
50     ASSERT_NE(ta2taSession, 0);
51 
52     ASSERT_STREQ(value.inBuffer, g_teeInout);
53     ASSERT_EQ(value.inBufferLen, g_teeInoutLen);
54 
55     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
56     ASSERT_EQ(ret, TEEC_SUCCESS);
57     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
58 }
59 
60 /**
61  * @testcase.name      : TEE_OpenTASession_With_UUIDIsNULL
62  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA while uuid is null
63  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
64  */
65 TEE_TEST(TeeTCF2TA2TATest, TEE_OpenTASession_With_UUIDIsNULL, Function | MediumTest | Level0)
66 {
67     TEEC_Result ret;
68     uint32_t ta2taSession;
69     uint32_t origin = 0;
70     TestData value = { 0 };
71     value.caseId = INPUT_ISNULL;
72     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
73 
74     value.inBufferLen = BIG_SIZE;
75     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
76     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
77     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
78 }
79 
80 /**
81  * @testcase.name      : TEE_OpenTASession_With_OriginIsNULL
82  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA while origin is null
83  * @testcase.expect    : return TEEC_SUCCESS
84  */
85 TEE_TEST(TeeTCF2TA2TATest, TEE_OpenTASession_With_OriginIsNULL, Function | MediumTest | Level0)
86 {
87     TEEC_Result ret;
88     uint32_t ta2taSession;
89     uint32_t origin = 0;
90     TestData value = { 0 };
91     value.caseId = RETURNORIGIN_ISNULL;
92     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
93 
94     value.inBufferLen = BIG_SIZE;
95     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
96     ASSERT_EQ(ret, TEEC_SUCCESS);
97     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
98     ASSERT_NE(ta2taSession, 0);
99 
100     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
101     ASSERT_EQ(ret, TEEC_SUCCESS);
102     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
103 }
104 
105 /**
106  * @testcase.name      : TEE_OpenTASession_With_SessionIsNULL
107  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA while session is null
108  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
109  */
110 TEE_TEST(TeeTCF2TA2TATest, TEE_OpenTASession_With_SessionIsNULL, Function | MediumTest | Level0)
111 {
112     TEEC_Result ret;
113     uint32_t ta2taSession;
114     uint32_t origin = 0;
115     TestData value = { 0 };
116     value.caseId = OUTPUT_ISNULL;
117     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
118 
119     value.inBufferLen = BIG_SIZE;
120     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
121     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
122     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
123 }
124 
125 /**
126  * @testcase.name      : TEE_OpenTASession_With_NoAvailableSession
127  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA while session is null
128  * @testcase.expect    : return TEEC_ERROR_ACCESS_CONFLICT
129  */
130 TEE_TEST(TeeTCF1Test, TEE_OpenTASession_With_NoAvailableSession, Function | MediumTest | Level0)
131 {
132     TEEC_Result ret;
133     uint32_t ta2taSession;
134     uint32_t origin = 0;
135     TestData value = { 0 };
136     value.caseId = 0;
137 
138     value.uuid = TCF_API_UUID_2; // this uuid is for ta2, this is a single session ta
139     ClientSessionMgr sess;
140     ret = sess.Start(&value.uuid);
141     EXPECT_EQ(ret, TEEC_SUCCESS);
142 
143     value.inBufferLen = BIG_SIZE;
144     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
145     sess.Destroy();
146     ASSERT_EQ(ret, TEEC_ERROR_ACCESS_CONFLICT);
147     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
148 }
149 
150 /**
151  * @testcase.name      : TEE_OpenTASession_With_MaxSession
152  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA to reach max session
153  * @testcase.expect    : return TEEC_ERROR_SESSION_MAXIMUM
154  */
155 TEE_TEST(TeeTCF2TA2TATest, TEE_OpenTASession_With_MaxSession, Function | MediumTest | Level0)
156 {
157     TEEC_Result ret;
158     uint32_t ta2taSession[8] = { 0 };
159     uint32_t origin = 0;
160     TestData value = { 0 };
161     value.caseId = 0;
162     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
163     int i;
164     value.inBufferLen = BIG_SIZE;
165 
166     for (i = 0; i <= 6; i++) {
167         ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession[i], &value, &origin);
168         ASSERT_EQ(ret, TEEC_SUCCESS);
169         ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
170         ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
171         ASSERT_NE(ta2taSession[i], 0);
172         if (i >= 1)
173             ASSERT_NE(ta2taSession[i], ta2taSession[i - 1]);
174     }
175 
176     // ta2 has reach max session,so this time will open session fail
177     value.inBufferLen = BIG_SIZE;
178     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession[i], &value, &origin);
179     ASSERT_EQ(ret, TEEC_ERROR_SESSION_MAXIMUM);
180     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
181     ASSERT_EQ(ta2taSession[i], 0);
182 }
183 
184 /**
185  * @testcase.name      : TEE_OpenTASession_With_UUIDIsNotExist
186  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA while uuid is not exist
187  * @testcase.expect    : return TEEC_ERROR_ITEM_NOT_FOUND
188  */
189 TEE_TEST(TeeTCF2TA2TATest, TEE_OpenTASession_With_UUIDIsNotExist, Function | MediumTest | Level0)
190 {
191     TEEC_Result ret;
192     uint32_t ta2taSession;
193     uint32_t origin = 0;
194     TestData value = { 0 };
195     value.caseId = 0;
196     value.uuid = UUID_TA_NOT_EXIST; // this uuid is for ta2
197 
198     value.inBufferLen = BIG_SIZE;
199     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
200     ASSERT_EQ(ret, TEEC_ERROR_ITEM_NOT_FOUND);
201     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
202 }
203 
204 /**
205  * @testcase.name      : TEE_OpenTASession_With_TA2Crash
206  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA while ta2 is crashed
207  * @testcase.expect    : return TEEC_ERROR_TARGET_DEAD
208  */
209 TEE_TEST(TeeTCF2TA2TATest, TEE_OpenTASession_With_TA2Crash, Function | MediumTest | Level0)
210 {
211     TEEC_Result ret;
212     uint32_t ta2taSession;
213     uint32_t origin = 0;
214     TestData value = { 0 };
215     value.caseId = TA_CRASH_FLAG;
216     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
217 
218     value.inBufferLen = BIG_SIZE;
219     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
220 #ifndef TEST_STUB
221     ASSERT_EQ(ret, TEEC_ERROR_TARGET_DEAD);
222     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
223 #else
224     ASSERT_EQ(ret, TEEC_SUCCESS);
225 #endif
226 }
227 
228 /**
229  * @testcase.name      : TEE_OpenTASession_With_BufferNoFillNoShare
230  * @testcase.desc      : test TA call TEE_OpenTASession to call other TA while buffer hint is
231  * TEE_MALLOC_NO_FILL|TEE_MALLOC_NO_SHARE
232  * @testcase.expect    : return TEEC_SUCCESS
233  */
234 TEE_TEST(TeeTCF2TA2TATest, TEE_OpenTASession_With_BufferNoFillNoShare, Function | MediumTest | Level0)
235 {
236     TEEC_Result ret;
237     uint32_t ta2taSession;
238     uint32_t origin = 0;
239     TestData value = { 0 };
240     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
241     g_teeInoutLen = strlen(g_teeInout) + 1;
242 
243     value.caseId = BUFFER_NOFILLNOSHARE;
244     value.inBufferLen = BIG_SIZE;
245 
246     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
247     ASSERT_EQ(ret, TEEC_SUCCESS);
248     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
249     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
250     ASSERT_NE(ta2taSession, 0);
251 
252     ASSERT_STREQ(value.inBuffer, g_teeInout);
253     ASSERT_EQ(value.inBufferLen, g_teeInoutLen);
254 
255     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
256     ASSERT_EQ(ret, TEEC_SUCCESS);
257     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
258 }
259 
260 /**
261  * @testcase.name      : TEE_CloseTASession_With_MaxSession
262  * @testcase.desc      : test TA call TEE_CloseTASession when TA to reach max session, then can open new session to ta2
263  * @testcase.expect    : return TEEC_SUCCESS
264  */
265 TEE_TEST(TeeTCF2TA2TATest, TEE_CloseTASession_With_MaxSession, Function | MediumTest | Level0)
266 {
267     TEEC_Result ret;
268     uint32_t ta2taSession[8] = { 0 };
269     uint32_t origin = 0;
270     TestData value = { 0 };
271     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
272     int i;
273     value.inBufferLen = BIG_SIZE;
274 
275     for (i = 0; i <= 6; i++) {
276         ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession[i], &value, &origin);
277         ASSERT_EQ(ret, TEEC_SUCCESS);
278         ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
279         ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
280         ASSERT_NE(ta2taSession[i], 0);
281         if (i >= 1)
282             ASSERT_NE(ta2taSession[i], ta2taSession[i - 1]);
283     }
284 
285     // ta2 has reach max session,so this time will open session fail
286     value.inBufferLen = BIG_SIZE;
287     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession[7], &value, &origin);
288     ASSERT_EQ(ret, TEEC_ERROR_SESSION_MAXIMUM);
289     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
290     ASSERT_EQ(ta2taSession[7], 0);
291 
292     // close one session of ta2
293     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession[6], &origin);
294     ASSERT_EQ(ret, TEEC_SUCCESS);
295     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
296 
297     // ta2 has close one session, so this time will open session success
298     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession[6], &value, &origin);
299     ASSERT_EQ(ret, TEEC_SUCCESS);
300     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
301     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
302     ASSERT_NE(ta2taSession[6], 0);
303 }
304 
305 /**
306  * @testcase.name      : TEE_InvokeTACommand_With_PARAM_TYPE_MEMREF
307  * @testcase.desc      : test TA call TEE_InvokeTACommand to pass memref params to other TA
308  * @testcase.expect    : return TEEC_SUCCESS
309  */
310 TEE_TEST(TeeTCF2TA2TATest, TEE_InvokeTACommand_With_PARAM_TYPE_MEMREF, Function | MediumTest | Level0)
311 {
312     TEEC_Result ret;
313     uint32_t ta2taSession;
314     uint32_t origin = 0;
315     TestData value = { 0 };
316     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
317     g_teeOutputLen = strlen(g_teeOutput) + 1;
318     g_teeInoutLen = strlen(g_teeInout) + 1;
319     value.inBufferLen = BIG_SIZE;
320     value.outBufferLen = BIG_SIZE;
321 
322     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
323     ASSERT_EQ(ret, TEEC_SUCCESS);
324     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
325     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
326     ASSERT_NE(ta2taSession, 0);
327 
328     (void)memset_s(value.inBuffer, BIG_SIZE, 0x41, BIG_SIZE);
329 
330     ret = Invoke_InvokeTACommand(GetSession(), CMD_TEE_InvokeTACommand, ta2taSession, &value, &origin);
331     ASSERT_EQ(ret, TEEC_SUCCESS);
332     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
333     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
334 
335     ASSERT_STREQ(value.inBuffer, g_teeInout);
336     ASSERT_EQ(value.inBufferLen, g_teeInoutLen);
337     ASSERT_STREQ(value.outBuffer, g_teeOutput);
338     ASSERT_EQ(value.outBufferLen, g_teeOutputLen);
339 
340     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
341     ASSERT_EQ(ret, TEEC_SUCCESS);
342     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
343 }
344 
345 /**
346  * @testcase.name      : TEE_InvokeTACommand_With_SessionIsNull
347  * @testcase.desc      : test TA call TEE_InvokeTACommand to other TA while session is null
348  * @testcase.expect    : return TEEC_ERROR_ITEM_NOT_FOUND
349  */
350 TEE_TEST(TeeTCF2TA2TATest, TEE_InvokeTACommand_With_SessionIsNull, Function | MediumTest | Level0)
351 {
352     TEEC_Result ret;
353     uint32_t ta2taSession;
354     uint32_t origin = 0;
355     TestData value = { 0 };
356     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
357     value.inBufferLen = BIG_SIZE;
358     value.outBufferLen = BIG_SIZE;
359 
360     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
361     ASSERT_EQ(ret, TEEC_SUCCESS);
362     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
363     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
364     ASSERT_NE(ta2taSession, 0);
365 
366     value.caseId = INPUT_ISNULL;
367     ret = Invoke_InvokeTACommand(GetSession(), CMD_TEE_InvokeTACommand, ta2taSession, &value, &origin);
368     ASSERT_EQ(ret, TEEC_ERROR_ITEM_NOT_FOUND);
369     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
370 
371     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
372     ASSERT_EQ(ret, TEEC_SUCCESS);
373     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
374 }
375 
376 /**
377  * @testcase.name      : TEE_InvokeTACommand_With_OriginIsNull
378  * @testcase.desc      : test TA call TEE_InvokeTACommand to other TA while origin is null
379  * @testcase.expect    : return TEEC_SUCCESS
380  */
381 TEE_TEST(TeeTCF2TA2TATest, TEE_InvokeTACommand_With_OriginIsNull, Function | MediumTest | Level0)
382 {
383     TEEC_Result ret;
384     uint32_t ta2taSession;
385     uint32_t origin = 0;
386     TestData value = { 0 };
387     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
388     g_teeOutputLen = strlen(g_teeOutput) + 1;
389     g_teeInoutLen = strlen(g_teeInout) + 1;
390     value.inBufferLen = BIG_SIZE;
391     value.outBufferLen = BIG_SIZE;
392 
393     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
394     ASSERT_EQ(ret, TEEC_SUCCESS);
395     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
396     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
397     ASSERT_NE(ta2taSession, 0);
398 
399     value.caseId = OUTPUT_ISNULL;
400     (void)memset_s(value.inBuffer, BIG_SIZE, 0x41, BIG_SIZE);
401     ret = Invoke_InvokeTACommand(GetSession(), CMD_TEE_InvokeTACommand, ta2taSession, &value, &origin);
402     ASSERT_EQ(ret, TEEC_SUCCESS);
403     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
404 
405     ASSERT_STREQ(value.inBuffer, g_teeInout);
406     ASSERT_EQ(value.inBufferLen, g_teeInoutLen);
407     ASSERT_STREQ(value.outBuffer, g_teeOutput);
408     ASSERT_EQ(value.outBufferLen, g_teeOutputLen);
409 
410     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
411     ASSERT_EQ(ret, TEEC_SUCCESS);
412     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
413 }
414 
415 /**
416  * @testcase.name      : TEE_InvokeTACommand_With_TA2Crash
417  * @testcase.desc      : test TA call TEE_InvokeTACommand to other TA while ta2 is crash
418  * @testcase.expect    : return TEEC_ERROR_TARGET_DEAD
419  */
420 TEE_TEST(TeeTCF2TA2TATest, TEE_InvokeTACommand_With_TA2Crash, Function | MediumTest | Level0)
421 {
422     TEEC_Result ret;
423     uint32_t ta2taSession;
424     uint32_t origin = 0;
425     TestData value = { 0 };
426     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
427     value.inBufferLen = BIG_SIZE;
428     value.outBufferLen = BIG_SIZE;
429 
430     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
431     ASSERT_EQ(ret, TEEC_SUCCESS);
432     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
433     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
434     ASSERT_NE(ta2taSession, 0);
435 
436     value.caseId = TA_CRASH_FLAG;
437     ret = Invoke_InvokeTACommand(GetSession(), CMD_TEE_InvokeTACommand, ta2taSession, &value, &origin);
438 #ifndef TEST_STUB
439     ASSERT_EQ(ret, TEEC_ERROR_TARGET_DEAD);
440     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
441 #else
442     ASSERT_EQ(ret, TEEC_SUCCESS);
443 #endif
444 
445     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
446     ASSERT_EQ(ret, TEEC_SUCCESS);
447     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
448 }
449 
450 #ifdef TEST_BLOCK
451 /**
452  * @testcase.name      : TEE_InvokeTACommand_With_MaxShareBufferSize
453  * @testcase.desc      : test TA call TEE_InvokeTACommand to pass memref to other TA while buffer size is MAX_SHARE_SIZE
454  * @testcase.expect    : return TEEC_SUCCESS
455  */
456 TEE_TEST(TeeTCF2TA2TATest, TEE_InvokeTACommand_With_MaxShareBufferSize, Function | MediumTest | Level0)
457 {
458     TEEC_Result ret;
459     uint32_t ta2taSession;
460     uint32_t origin = 0;
461     TestData value = { 0 };
462     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
463     value.inBufferLen = BIG_SIZE;
464 
465     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
466     ASSERT_EQ(ret, TEEC_SUCCESS);
467     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
468     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
469     ASSERT_NE(ta2taSession, 0);
470 
471     value.caseId = BUFFERSIZE_ISTOOBIG;
472     value.outBufferLen = BIG_SIZE;
473     ret = Invoke_InvokeTACommand(GetSession(), CMD_TEE_InvokeTACommand, ta2taSession, &value, &origin);
474     ASSERT_EQ(ret, TEEC_SUCCESS);
475     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
476 
477     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
478     ASSERT_EQ(ret, TEEC_SUCCESS);
479     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
480 }
481 #endif
482 /**
483  * @testcase.name      : TEE_InvokeTACommand_With_BufferNoFillNoShare
484  * @testcase.desc      : test TA call TEE_InvokeTACommand to pass memref to TA2 while buffer hint is
485  * TEE_MALLOC_NO_FILL|TEE_MALLOC_NO_SHARE
486  * @testcase.expect    : return TEEC_SUCCESS
487  */
488 TEE_TEST(TeeTCF2TA2TATest, TEE_InvokeTACommand_With_BufferNoFillNoShare, Function | MediumTest | Level0)
489 {
490     TEEC_Result ret;
491     uint32_t ta2taSession;
492     uint32_t origin = 0;
493     TestData value = { 0 };
494     value.uuid = TCF_API_UUID_1; // this uuid is for ta2
495     value.inBufferLen = BIG_SIZE;
496     value.outBufferLen = BIG_SIZE;
497     g_teeInoutLen = strlen(g_teeInout) + 1;
498 
499     ret = Invoke_OpenTASession(GetSession(), CMD_TEE_OpenTASession, &ta2taSession, &value, &origin);
500     ASSERT_EQ(ret, TEEC_SUCCESS);
501     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
502     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
503     ASSERT_NE(ta2taSession, 0);
504 
505     value.caseId = BUFFER_NOFILLNOSHARE;
506     ret = Invoke_InvokeTACommand(GetSession(), CMD_TEE_InvokeTACommand, ta2taSession, &value, &origin);
507     ASSERT_EQ(ret, TEEC_SUCCESS);
508     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
509     ASSERT_EQ(value.origin, TEEC_ORIGIN_TEE);
510 
511     ASSERT_STREQ(value.inBuffer, g_teeInout);
512     ASSERT_EQ(value.inBufferLen, g_teeInoutLen);
513 
514     ret = Invoke_CloseTASession(GetSession(), CMD_TEE_CloseTASession, ta2taSession, &origin);
515     ASSERT_EQ(ret, TEEC_SUCCESS);
516     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
517 }
518