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 <tee_client_api.h> 17 #include <tee_client_type.h> 18 #include <test_defines.h> 19 #include <test_log.h> 20 #include <test_tcf_cmdid.h> 21 22 using namespace testing::ext; 23 /** 24 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TA_DATASIZE 25 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TA_DATASIZE 26 * @testcase.expect : return TEEC_SUCCESS 27 */ 28 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TA_DATASIZE, Function | MediumTest | Level0) 29 { 30 TEEC_Result ret; 31 int rc; 32 TestData value = { 0 }; 33 value.cmd = CMD_TEE_GetPropertyAsU32; 34 value.propSet = TEE_PROPSET_CURRENT_TA; 35 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TA_DATASIZE, sizeof(GPD_TA_DATASIZE)); 36 ASSERT_EQ(rc, 0); 37 value.inBufferLen = sizeof(GPD_TA_DATASIZE); 38 39 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 40 ASSERT_EQ(ret, TEEC_SUCCESS); 41 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 42 ASSERT_EQ(atoi(value.outBuffer), VALUE_PREDEFINED_DATASIZE); 43 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 44 } 45 46 /** 47 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TA_STACKSIZE 48 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TA_STACKSIZE 49 * @testcase.expect : return TEEC_SUCCESS, get value is correct 50 */ 51 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TA_STACKSIZE, Function | MediumTest | Level0) 52 { 53 TEEC_Result ret; 54 55 int rc; 56 TestData value = { 0 }; 57 value.cmd = CMD_TEE_GetPropertyAsU32; 58 value.propSet = TEE_PROPSET_CURRENT_TA; 59 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TA_STACKSIZE, sizeof(GPD_TA_STACKSIZE)); 60 ASSERT_EQ(rc, 0); 61 value.inBufferLen = sizeof(GPD_TA_STACKSIZE); 62 63 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 64 ASSERT_EQ(ret, TEEC_SUCCESS); 65 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 66 ASSERT_EQ(atoi(value.outBuffer), VALUE_PREDEFINED_STACKSIZE); 67 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 68 } 69 70 /** 71 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_CLIENT_ENDIAN 72 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_CLIENT_ENDIAN 73 * @testcase.expect : return TEEC_SUCCESS, get value is correct 74 */ 75 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_CLIENT_ENDIAN, Function | MediumTest | Level0) 76 { 77 TEEC_Result ret; 78 int rc; 79 80 TestData value = { 0 }; 81 value.cmd = CMD_TEE_GetPropertyAsU32; 82 value.propSet = TEE_PROPSET_CURRENT_CLIENT; 83 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_CLIENT_ENDIAN, sizeof(GPD_CLIENT_ENDIAN)); 84 ASSERT_EQ(rc, 0); 85 value.inBufferLen = sizeof(GPD_CLIENT_ENDIAN); 86 87 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 88 ASSERT_EQ(ret, TEEC_SUCCESS); 89 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 90 ASSERT_EQ(atoi(value.outBuffer), VALUE_PREDEFINED_CLIENT_ENDIAN); 91 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 92 } 93 94 /** 95 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_INTERNALCORE_VERSION 96 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TEE_INTERNALCORE_VERSION 97 * @testcase.expect : return TEEC_SUCCESS 98 */ 99 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_INTERNALCORE_VERSION, Function | MediumTest | Level0) 100 { 101 TEEC_Result ret; 102 int rc; 103 TestData value = { 0 }; 104 value.cmd = CMD_TEE_GetPropertyAsU32; 105 value.propSet = TEE_PROPSET_IMPLEMENTATION; 106 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TEE_INTERNALCORE_VERSION, sizeof(GPD_TEE_INTERNALCORE_VERSION)); 107 ASSERT_EQ(rc, 0); 108 value.inBufferLen = sizeof(GPD_TEE_INTERNALCORE_VERSION); 109 110 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 111 ASSERT_EQ(ret, TEEC_SUCCESS); 112 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 113 ASSERT_EQ(atoi(value.outBuffer), TEE_INTERNAL_CORE_VERSION); 114 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 115 } 116 117 /** 118 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_SYSTEM_TIME_PROTECTIONLEVEL 119 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TEE_SYSTEM_TIME_PROTECTIONLEVEL 120 * @testcase.expect : return TEEC_SUCCESS, get value is correct 121 */ 122 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_SYSTEM_TIME_PROTECTIONLEVEL, Function | MediumTest | Level0) 123 { 124 TEEC_Result ret; 125 int rc; 126 127 TestData value = { 0 }; 128 value.cmd = CMD_TEE_GetPropertyAsU32; 129 value.propSet = TEE_PROPSET_IMPLEMENTATION; 130 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TEE_SYSTEM_TIME_PROTECTIONLEVEL, 131 sizeof(GPD_TEE_SYSTEM_TIME_PROTECTIONLEVEL)); 132 ASSERT_EQ(rc, 0); 133 value.inBufferLen = sizeof(GPD_TEE_SYSTEM_TIME_PROTECTIONLEVEL); 134 135 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 136 ASSERT_EQ(ret, TEEC_SUCCESS); 137 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 138 ASSERT_EQ(atoi(value.outBuffer), TEE_TIME_PROTECT_LEVEL); 139 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 140 } 141 142 /** 143 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_TA_PERSISTENT_TIME_PROTECTIONLEVEL 144 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TEE_TA_PERSISTENT_TIME_PROTECTIONLEVEL 145 * @testcase.expect : return TEEC_SUCCESS, get value is correct 146 */ 147 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_TA_PERSISTENT_TIME_PROTECTIONLEVEL, 148 Function | MediumTest | Level0) 149 { 150 TEEC_Result ret; 151 int rc; 152 153 TestData value = { 0 }; 154 value.cmd = CMD_TEE_GetPropertyAsU32; 155 value.propSet = TEE_PROPSET_IMPLEMENTATION; 156 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TEE_TA_PERSISTENT_TIME_PROTECTIONLEVEL, 157 sizeof(GPD_TEE_TA_PERSISTENT_TIME_PROTECTIONLEVEL)); 158 ASSERT_EQ(rc, 0); 159 value.inBufferLen = sizeof(GPD_TEE_TA_PERSISTENT_TIME_PROTECTIONLEVEL); 160 161 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 162 ASSERT_EQ(ret, TEEC_SUCCESS); 163 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 164 ASSERT_EQ(atoi(value.outBuffer), TA_TIME_PROTECT_LEVEL); 165 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 166 } 167 168 /** 169 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_ARITH_MAXBIGINTSIZE 170 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TEE_ARITH_MAXBIGINTSIZE 171 * @testcase.expect : return TEEC_SUCCESS, get value is correct 172 */ 173 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_ARITH_MAXBIGINTSIZE, Function | MediumTest | Level0) 174 { 175 TEEC_Result ret; 176 int rc; 177 178 TestData value = { 0 }; 179 value.cmd = CMD_TEE_GetPropertyAsU32; 180 value.propSet = TEE_PROPSET_IMPLEMENTATION; 181 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TEE_ARITH_MAXBIGINTSIZE, sizeof(GPD_TEE_ARITH_MAXBIGINTSIZE)); 182 ASSERT_EQ(rc, 0); 183 value.inBufferLen = sizeof(GPD_TEE_ARITH_MAXBIGINTSIZE); 184 185 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 186 ASSERT_EQ(ret, TEEC_SUCCESS); 187 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 188 ASSERT_EQ(atoi(value.outBuffer), MAX_BIG_INT_SIZE); 189 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 190 } 191 192 /** 193 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_ANTIROLLBACK_PROTECTIONLEVEL 194 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TEE_ANTIROLLBACK_PROTECTIONLEVEL 195 * @testcase.expect : return TEEC_SUCCESS, get value is correct 196 */ 197 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_ANTIROLLBACK_PROTECTIONLEVEL, 198 Function | MediumTest | Level0) 199 { 200 TEEC_Result ret; 201 int rc; 202 203 TestData value = { 0 }; 204 value.cmd = CMD_TEE_GetPropertyAsU32; 205 value.propSet = TEE_PROPSET_IMPLEMENTATION; 206 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TEE_ANTIROLLBACK_PROTECTIONLEVEL, 207 sizeof(GPD_TEE_ANTIROLLBACK_PROTECTIONLEVEL)); 208 ASSERT_EQ(rc, 0); 209 value.inBufferLen = sizeof(GPD_TEE_ANTIROLLBACK_PROTECTIONLEVEL); 210 211 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 212 ASSERT_EQ(ret, TEEC_SUCCESS); 213 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 214 ASSERT_EQ(atoi(value.outBuffer), 0); 215 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 216 } 217 218 /** 219 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_ROLLBACKDETECT_PROTECTIONLEVEL 220 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TEE_ROLLBACKDETECT_PROTECTIONLEVEL 221 * @testcase.expect : return TEEC_SUCCESS, get value is correct 222 */ 223 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_ROLLBACKDETECT_PROTECTIONLEVEL, 224 Function | MediumTest | Level0) 225 { 226 TEEC_Result ret; 227 int rc; 228 229 TestData value = { 0 }; 230 value.cmd = CMD_TEE_GetPropertyAsU32; 231 value.propSet = TEE_PROPSET_IMPLEMENTATION; 232 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TEE_ROLLBACKDETECT_PROTECTIONLEVEL, 233 sizeof(GPD_TEE_ROLLBACKDETECT_PROTECTIONLEVEL)); 234 ASSERT_EQ(rc, 0); 235 value.inBufferLen = sizeof(GPD_TEE_ROLLBACKDETECT_PROTECTIONLEVEL); 236 237 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 238 ASSERT_EQ(ret, TEEC_SUCCESS); 239 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 240 ASSERT_EQ(atoi(value.outBuffer), 0); 241 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 242 } 243 244 /** 245 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_EVENT_MAXSOURCES 246 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TEE_EVENT_MAXSOURCES 247 * @testcase.expect : return TEEC_SUCCESS, get value is correct 248 */ 249 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_EVENT_MAXSOURCES, Function | MediumTest | Level0) 250 { 251 TEEC_Result ret; 252 int rc; 253 254 TestData value = { 0 }; 255 value.cmd = CMD_TEE_GetPropertyAsU32; 256 value.propSet = TEE_PROPSET_IMPLEMENTATION; 257 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TEE_EVENT_MAXSOURCES, sizeof(GPD_TEE_EVENT_MAXSOURCES)); 258 ASSERT_EQ(rc, 0); 259 value.inBufferLen = sizeof(GPD_TEE_EVENT_MAXSOURCES); 260 261 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 262 ASSERT_EQ(ret, TEEC_SUCCESS); 263 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 264 ASSERT_EQ(atoi(value.outBuffer), 0); 265 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 266 } 267 268 /** 269 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_API_LEVEL 270 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TEE_API_LEVEL 271 * @testcase.expect : return TEEC_SUCCESS, get value is correct 272 */ 273 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TEE_API_LEVEL, Function | MediumTest | Level0) 274 { 275 TEEC_Result ret; 276 int rc; 277 278 TestData value = { 0 }; 279 value.cmd = CMD_TEE_GetPropertyAsU32; 280 value.propSet = TEE_PROPSET_IMPLEMENTATION; 281 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TEE_API_LEVEL, sizeof(GPD_TEE_API_LEVEL)); 282 ASSERT_EQ(rc, 0); 283 value.inBufferLen = sizeof(GPD_TEE_API_LEVEL); 284 285 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 286 ASSERT_EQ(ret, TEEC_SUCCESS); 287 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 288 ASSERT_EQ(atoi(value.outBuffer), TEE_MAX_API_LEVEL_CONFIG); 289 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 290 } 291 292 /** 293 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_GPD_TA_API_LEVEL 294 * @testcase.desc : test TA call TEE_GetPropertyAsU32 to get value of GPD_TA_API_LEVEL 295 * @testcase.expect : return TEEC_SUCCESS, get value is correct 296 */ 297 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_GPD_TA_API_LEVEL, Function | MediumTest | Level0) 298 { 299 TEEC_Result ret; 300 int rc; 301 302 TestData value = { 0 }; 303 value.cmd = CMD_TEE_GetPropertyAsU32; 304 value.propSet = TEE_PROPSET_CURRENT_TA; 305 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TA_API_LEVEL, sizeof(GPD_TA_API_LEVEL)); 306 ASSERT_EQ(rc, 0); 307 value.inBufferLen = sizeof(GPD_TA_API_LEVEL); 308 309 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 310 ASSERT_EQ(ret, TEEC_SUCCESS); 311 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 312 ASSERT_EQ(atoi(value.outBuffer), API_LEVEL1_2); 313 ASSERT_EQ(value.outBufferLen, strlen(value.outBuffer) + 1); 314 } 315 316 /** 317 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_NameIsNull 318 * @testcase.desc : test TA call TEE_GetPropertyAsU32 for name is null 319 * @testcase.expect : return TEEC_ERROR_ITEM_NOT_FOUND 320 */ 321 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_NameIsNull, Function | MediumTest | Level0) 322 { 323 TEEC_Result ret; 324 325 TestData value = { 0 }; 326 value.cmd = CMD_TEE_GetPropertyAsU32; 327 value.caseId = INPUT_ISNULL; 328 value.propSet = TEE_PROPSET_CURRENT_TA; 329 330 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 331 ASSERT_EQ(ret, TEEC_ERROR_ITEM_NOT_FOUND); 332 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 333 } 334 335 /** 336 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_NameIsZero 337 * @testcase.desc : test TA call TEE_GetPropertyAsU32 for name value is zero 338 * @testcase.expect : return TEEC_ERROR_ITEM_NOT_FOUND 339 */ 340 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_NameIsZero, Function | MediumTest | Level0) 341 { 342 TEEC_Result ret; 343 344 TestData value = { 0 }; 345 value.cmd = CMD_TEE_GetPropertyAsU32; 346 value.propSet = TEE_PROPSET_CURRENT_TA; 347 348 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 349 ASSERT_EQ(ret, TEEC_ERROR_ITEM_NOT_FOUND); 350 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 351 } 352 353 /** 354 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_ValueIsNull 355 * @testcase.desc : test TA call TEE_GetPropertyAsU32 for value is null 356 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS 357 */ 358 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_ValueIsNull, Function | MediumTest | Level0) 359 { 360 TEEC_Result ret; 361 362 int rc; 363 TestData value = { 0 }; 364 value.cmd = CMD_TEE_GetPropertyAsU32; 365 value.caseId = OUTPUT_ISNULL; 366 value.propSet = TEE_PROPSET_CURRENT_TA; 367 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TA_DATASIZE, sizeof(GPD_TA_DATASIZE)); 368 ASSERT_EQ(rc, 0); 369 value.inBufferLen = sizeof(GPD_TA_DATASIZE); 370 371 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 372 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS); 373 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 374 } 375 376 /** 377 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_NameNotFound 378 * @testcase.desc : test TA call TEE_GetPropertyAsU32 while Name Not Found 379 * @testcase.expect : return TEEC_ERROR_ITEM_NOT_FOUND 380 */ 381 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_NameNotFound, Function | MediumTest | Level0) 382 { 383 TEEC_Result ret; 384 385 int rc; 386 TestData value = { 0 }; 387 value.cmd = CMD_TEE_GetPropertyAsU32; 388 value.propSet = TEE_PROPSET_CURRENT_TA; 389 rc = memcpy_s(value.inBuffer, BIG_SIZE, PROPERTY_NAME_UNKNOWN, sizeof(PROPERTY_NAME_UNKNOWN)); 390 ASSERT_EQ(rc, 0); 391 value.inBufferLen = sizeof(PROPERTY_NAME_UNKNOWN); 392 393 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 394 ASSERT_EQ(ret, TEEC_ERROR_ITEM_NOT_FOUND); 395 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 396 } 397 398 /** 399 * @testcase.name : TEE_GetPropertyAsU32_WithoutEnum_NameNotU32 400 * @testcase.desc : test TA call TEE_GetPropertyAsU32 while Name type is not U32 401 * @testcase.expect : return TEEC_ERROR_BAD_FORMAT 402 */ 403 TEE_TEST(TeeTCF1Test, TEE_GetPropertyAsU32_WithoutEnum_NameNotU32, Function | MediumTest | Level0) 404 { 405 TEEC_Result ret; 406 407 int rc; 408 TestData value = { 0 }; 409 value.cmd = CMD_TEE_GetPropertyAsU32; 410 value.propSet = TEE_PROPSET_CURRENT_TA; 411 rc = memcpy_s(value.inBuffer, BIG_SIZE, GPD_TA_DESCRIPTION, sizeof(GPD_TA_DESCRIPTION)); 412 ASSERT_EQ(rc, 0); 413 value.inBufferLen = sizeof(GPD_TA_DESCRIPTION); 414 415 ret = Invoke_GetPropertyAsX(GetContext(), GetSession(), &value); 416 ASSERT_EQ(ret, TEEC_ERROR_BAD_FORMAT); 417 ASSERT_EQ(value.origin, TEEC_ORIGIN_TRUSTED_APP); 418 } 419