1 /**
2 * Copyright (c) 2024 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 <gtest/gtest.h>
17 #include <cstring>
18
19 #include "libabckit/include/c/abckit.h"
20 #include "helpers/helpers.h"
21 #include "libabckit/include/c/metadata_core.h"
22
23 namespace libabckit::test {
24
25 static auto g_impl = AbckitGetApiImpl(ABCKIT_VERSION_RELEASE_1_0_0);
26 static auto g_implI = AbckitGetInspectApiImpl(ABCKIT_VERSION_RELEASE_1_0_0);
27 static auto g_implM = AbckitGetModifyApiImpl(ABCKIT_VERSION_RELEASE_1_0_0);
28
29 static constexpr auto MODIFIED_DYNAMIC =
30 ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic_modified.abc";
31 static constexpr auto MODIFIED_STATIC =
32 ABCKIT_ABC_DIR "ut/metadata_core/inspect_api/literals/literals_static_modified.abc";
33
34 class LibAbcKitInspectApiLiteralsTest : public ::testing::Test {};
35
36 // Test: test-kind=api, api=InspectApiImpl::literalGetBool, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetBool_1)37 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetBool_1)
38 {
39 AbckitFile *file = nullptr;
40 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/inspect_api/literals/literals_dynamic.abc", &file);
41 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
42 auto val = g_implI->literalGetBool(res);
43 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
44 ASSERT_TRUE(val);
45 // Write output file
46 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
47 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
48 g_impl->closeFile(file);
49 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
50 }
51
52 // Test: test-kind=api, api=InspectApiImpl::literalGetU8, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU8_1)53 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU8_1)
54 {
55 AbckitFile *file = nullptr;
56 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
57 AbckitLiteral *res = g_implM->createLiteralU8(file, 1);
58 auto val = g_implI->literalGetU8(res);
59 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
60 ASSERT_EQ(val, 1);
61 // Write output file
62 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
63 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
64 g_impl->closeFile(file);
65 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
66 }
67
68 // Test: test-kind=api, api=InspectApiImpl::literalGetU16, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU16_1)69 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU16_1)
70 {
71 AbckitFile *file = nullptr;
72 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
73 AbckitLiteral *res = g_implM->createLiteralU16(file, 1);
74 auto val = g_implI->literalGetU16(res);
75 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
76 ASSERT_EQ(val, 1);
77 // Write output file
78 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
79 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
80 g_impl->closeFile(file);
81 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
82 }
83
84 // Test: test-kind=api, api=InspectApiImpl::literalGetMethodAffiliate, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetMethodAffiliate_1)85 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetMethodAffiliate_1)
86 {
87 AbckitFile *file = nullptr;
88 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
89 AbckitLiteral *res = g_implM->createLiteralMethodAffiliate(file, 1);
90 auto val = g_implI->literalGetMethodAffiliate(res);
91 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
92 ASSERT_EQ(val, 1);
93 // Write output file
94 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
95 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
96 g_impl->closeFile(file);
97 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
98 }
99
100 // Test: test-kind=api, api=InspectApiImpl::literalGetU32, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU32_1)101 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU32_1)
102 {
103 AbckitFile *file = nullptr;
104 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
105 AbckitLiteral *res = g_implM->createLiteralU32(file, 1);
106 auto val = g_implI->literalGetU32(res);
107 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
108 ASSERT_EQ(val, 1);
109 // Write output file
110 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
111 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
112 g_impl->closeFile(file);
113 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
114 }
115
116 // Test: test-kind=api, api=InspectApiImpl::literalGetU64, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU64_1)117 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU64_1)
118 {
119 AbckitFile *file = nullptr;
120 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
121 AbckitLiteral *res = g_implM->createLiteralU64(file, 1);
122 auto val = g_implI->literalGetU64(res);
123 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
124 ASSERT_EQ(val, 1);
125 // Write output file
126 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
127 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
128 g_impl->closeFile(file);
129 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
130 }
131
132 // Test: test-kind=api, api=InspectApiImpl::literalGetFloat, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetFloat_1)133 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetFloat_1)
134 {
135 AbckitFile *file = nullptr;
136 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
137 AbckitLiteral *res = g_implM->createLiteralFloat(file, 1.0);
138 auto val = g_implI->literalGetFloat(res);
139 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
140 ASSERT_FLOAT_EQ(val, 1.0);
141 // Write output file
142 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
143 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
144 g_impl->closeFile(file);
145 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
146 }
147
148 // Test: test-kind=api, api=InspectApiImpl::literalGetDouble, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetDouble_1)149 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetDouble_1)
150 {
151 AbckitFile *file = nullptr;
152 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
153 AbckitLiteral *res = g_implM->createLiteralDouble(file, 1.0);
154 auto val = g_implI->literalGetDouble(res);
155 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
156 ASSERT_DOUBLE_EQ(val, 1.0);
157 // Write output file
158 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
159 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
160 g_impl->closeFile(file);
161 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
162 }
163
164 // Test: test-kind=api, api=InspectApiImpl::literalGetLiteralArray, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetLiteralArray_1)165 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetLiteralArray_1)
166 {
167 AbckitFile *file = nullptr;
168 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
169 const double val1 = 0.7;
170 const int val2 = 7U;
171 std::array<AbckitLiteral *, 2U> statlitarr = {g_implM->createLiteralDouble(file, val1),
172 g_implM->createLiteralU32(file, val2)};
173 AbckitLiteralArray *litarr = g_implM->createLiteralArray(file, statlitarr.data(), 2U);
174 AbckitLiteral *res = g_implM->createLiteralLiteralArray(file, litarr);
175 auto val = g_implI->literalGetLiteralArray(res);
176 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
177 ASSERT_EQ(val, litarr);
178 // Write output file
179 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
180 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
181 g_impl->closeFile(file);
182 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
183 }
184
185 // Test: test-kind=api, api=InspectApiImpl::literalGetString, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetString_1)186 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetString_1)
187 {
188 AbckitFile *file = nullptr;
189 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
190 AbckitLiteral *res = g_implM->createLiteralString(file, "asdf", strlen("asdf"));
191 auto val = g_implI->literalGetString(res);
192 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
193 ASSERT_EQ(helpers::AbckitStringToString(val), "asdf");
194 // Write output file
195 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
196 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
197 g_impl->closeFile(file);
198 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
199 }
200
201 // Test: test-kind=api, api=InspectApiImpl::literalGetMethod, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetMethod_1)202 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetMethod_1)
203 {
204 AbckitFile *file = nullptr;
205 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
206 AbckitLiteral *res = g_implM->createLiteralMethod(file, helpers::FindMethodByName(file, "foo"));
207 auto val = g_implI->literalGetMethod(res);
208 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
209 ASSERT_EQ(helpers::AbckitStringToString(val), "literals_dynamic.#*#foo");
210 // Write output file
211 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
212 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
213 g_impl->closeFile(file);
214 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
215 }
216
217 // Test: test-kind=api, api=InspectApiImpl::literalGetTag, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetTag_1)218 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetTag_1)
219 {
220 AbckitFile *file = nullptr;
221 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
222 AbckitLiteral *res = g_implM->createLiteralString(file, "asdf", strlen("asdf"));
223 ASSERT_EQ(g_implI->literalGetTag(res), ABCKIT_LITERAL_TAG_STRING);
224
225 // Write output file
226 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
227 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
228 g_impl->closeFile(file);
229 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
230 }
231
232 // Test: test-kind=api, api=InspectApiImpl::literalGetFile, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetFile_1)233 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetFile_1)
234 {
235 AbckitFile *file = nullptr;
236 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
237 AbckitLiteral *res = g_implM->createLiteralString(file, "asdf", strlen("asdf"));
238 ASSERT_EQ(g_implI->literalGetFile(res), file);
239
240 // Write output file
241 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
242 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
243 g_impl->closeFile(file);
244 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
245 }
246
247 // Test: test-kind=api, api=InspectApiImpl::literalArrayEnumerateElements, abc-kind=ArkTS1, category=positive,
248 // extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralArrayEnumerateElements_1)249 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralArrayEnumerateElements_1)
250 {
251 AbckitFile *file = nullptr;
252 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
253 const size_t loopCount = 10U;
254
255 const uint32_t val0 = 2;
256 const uint32_t shift = 30;
257 const uint32_t val1 = (val0 << shift) + 1;
258 const double val2 = 3.22;
259 auto checkLit = [val1, val2](AbckitLiteral *lit) {
260 auto tag = g_implI->literalGetTag(lit);
261 switch (tag) {
262 case ABCKIT_LITERAL_TAG_BOOL:
263 ASSERT_EQ(g_implI->literalGetBool(lit), true);
264 break;
265 case ABCKIT_LITERAL_TAG_INTEGER:
266 ASSERT_EQ(g_implI->literalGetU32(lit), val1);
267 break;
268 case ABCKIT_LITERAL_TAG_DOUBLE:
269 ASSERT_EQ(g_implI->literalGetDouble(lit), val2);
270 break;
271 case ABCKIT_LITERAL_TAG_STRING:
272 ASSERT_EQ(helpers::AbckitStringToString(g_implI->literalGetString(lit)), "asdf");
273 break;
274 default:
275 ASSERT_TRUE(false);
276 }
277 };
278
279 for (size_t i = 0; i < loopCount; ++i) {
280 auto arr = std::vector<AbckitLiteral *>({
281 g_implM->createLiteralBool(file, true),
282 g_implM->createLiteralU32(file, val1),
283 g_implM->createLiteralDouble(file, val2),
284 g_implM->createLiteralString(file, "asdf", strlen("asdf")),
285 });
286 auto litArr = g_implM->createLiteralArray(file, arr.data(), arr.size());
287 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
288
289 std::vector<AbckitLiteral *> newArr;
290 g_implI->literalArrayEnumerateElements(litArr, &newArr, [](AbckitFile *, AbckitLiteral *lit, void *data) {
291 (reinterpret_cast<std::vector<AbckitLiteral *> *>(data))->emplace_back(lit);
292 return true;
293 });
294
295 ASSERT_EQ(newArr.size(), 4U);
296 std::for_each(newArr.begin(), newArr.end(), [&](AbckitLiteral *lit) { checkLit(lit); });
297 }
298
299 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
300 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
301 g_impl->closeFile(file);
302 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
303 }
304
305 // Test: test-kind=api, api=InspectApiImpl::literalGetBool, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetBool_2)306 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetBool_2)
307 {
308 AbckitFile *file = nullptr;
309 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/inspect_api/literals/literals_static.abc", &file);
310 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
311 auto val = g_implI->literalGetBool(res);
312 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
313 ASSERT_TRUE(val);
314 // Write output file
315 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
316 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
317 g_impl->closeFile(file);
318 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
319 }
320
321 // Test: test-kind=api, api=InspectApiImpl::literalGetU8, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU8_2)322 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU8_2)
323 {
324 AbckitFile *file = nullptr;
325 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
326 AbckitLiteral *res = g_implM->createLiteralU8(file, 1);
327 auto val = g_implI->literalGetU8(res);
328 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
329 ASSERT_EQ(val, 1);
330 // Write output file
331 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
332 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
333 g_impl->closeFile(file);
334 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
335 }
336
337 // Test: test-kind=api, api=InspectApiImpl::literalGetU16, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU16_2)338 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU16_2)
339 {
340 AbckitFile *file = nullptr;
341 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
342 AbckitLiteral *res = g_implM->createLiteralU16(file, 1);
343 auto val = g_implI->literalGetU16(res);
344 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
345 ASSERT_EQ(val, 1);
346 // Write output file
347 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
348 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
349 g_impl->closeFile(file);
350 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
351 }
352
353 // Test: test-kind=api, api=InspectApiImpl::literalGetMethodAffiliate, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetMethodAffiliate_2)354 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetMethodAffiliate_2)
355 {
356 AbckitFile *file = nullptr;
357 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
358 AbckitLiteral *res = g_implM->createLiteralMethodAffiliate(file, 1);
359 auto val = g_implI->literalGetMethodAffiliate(res);
360 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
361 ASSERT_EQ(val, 1);
362 // Write output file
363 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
364 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
365 g_impl->closeFile(file);
366 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
367 }
368
369 // Test: test-kind=api, api=InspectApiImpl::literalGetU32, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU32_2)370 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU32_2)
371 {
372 AbckitFile *file = nullptr;
373 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
374 AbckitLiteral *res = g_implM->createLiteralU32(file, 1);
375 auto val = g_implI->literalGetU32(res);
376 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
377 ASSERT_EQ(val, 1);
378 // Write output file
379 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
380 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
381 g_impl->closeFile(file);
382 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
383 }
384
385 // Test: test-kind=api, api=InspectApiImpl::literalGetU64, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU64_2)386 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU64_2)
387 {
388 AbckitFile *file = nullptr;
389 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
390 AbckitLiteral *res = g_implM->createLiteralU64(file, 1);
391 auto val = g_implI->literalGetU64(res);
392 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
393 ASSERT_EQ(val, 1);
394 // Write output file
395 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
396 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
397 g_impl->closeFile(file);
398 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
399 }
400
401 // Test: test-kind=api, api=InspectApiImpl::literalGetFloat, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetFloat_2)402 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetFloat_2)
403 {
404 AbckitFile *file = nullptr;
405 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
406 AbckitLiteral *res = g_implM->createLiteralFloat(file, 1.0);
407 auto val = g_implI->literalGetFloat(res);
408 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
409 ASSERT_FLOAT_EQ(val, 1.0);
410 // Write output file
411 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
412 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
413 g_impl->closeFile(file);
414 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
415 }
416
417 // Test: test-kind=api, api=InspectApiImpl::literalGetDouble, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetDouble_2)418 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetDouble_2)
419 {
420 AbckitFile *file = nullptr;
421 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
422 AbckitLiteral *res = g_implM->createLiteralDouble(file, 1.0);
423 auto val = g_implI->literalGetDouble(res);
424 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
425 ASSERT_DOUBLE_EQ(val, 1.0);
426 // Write output file
427 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
428 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
429 g_impl->closeFile(file);
430 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
431 }
432
433 // Test: test-kind=api, api=InspectApiImpl::literalGetString, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetString_2)434 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetString_2)
435 {
436 AbckitFile *file = nullptr;
437 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
438 AbckitLiteral *res = g_implM->createLiteralString(file, "asdf", strlen("asdf"));
439 auto val = g_implI->literalGetString(res);
440 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
441 ASSERT_EQ(helpers::AbckitStringToString(val), "asdf");
442 // Write output file
443 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
444 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
445 g_impl->closeFile(file);
446 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
447 }
448
449 // Test: test-kind=api, api=InspectApiImpl::literalGetTag, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetTag_2)450 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetTag_2)
451 {
452 AbckitFile *file = nullptr;
453 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
454 AbckitLiteral *res = g_implM->createLiteralString(file, "asdf", strlen("asdf"));
455 ASSERT_EQ(g_implI->literalGetTag(res), ABCKIT_LITERAL_TAG_STRING);
456
457 // Write output file
458 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
459 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
460 g_impl->closeFile(file);
461 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
462 }
463
464 // Test: test-kind=api, api=InspectApiImpl::literalGetFile, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetFile_2)465 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetFile_2)
466 {
467 AbckitFile *file = nullptr;
468 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
469 AbckitLiteral *res = g_implM->createLiteralString(file, "asdf", strlen("asdf"));
470 ASSERT_EQ(g_implI->literalGetFile(res), file);
471
472 // Write output file
473 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
474 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
475 g_impl->closeFile(file);
476 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
477 }
478
479 // Test: test-kind=api, api=InspectApiImpl::literalGetBool, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetBool_3)480 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetBool_3)
481 {
482 AbckitFile *file = nullptr;
483 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/inspect_api/literals/literals_dynamic.abc", &file);
484 AbckitLiteral *res = g_implM->createLiteralU8(file, 1);
485 g_implI->literalGetBool(res);
486 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
487 // Write output file
488 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
489 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
490 g_impl->closeFile(file);
491 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
492 }
493
494 // Test: test-kind=api, api=InspectApiImpl::literalGetBool, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetBool_4)495 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetBool_4)
496 {
497 AbckitFile *file = nullptr;
498 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/inspect_api/literals/literals_static.abc", &file);
499 AbckitLiteral *res = g_implM->createLiteralU8(file, 1);
500 g_implI->literalGetBool(res);
501 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
502 // Write output file
503 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
504 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
505 g_impl->closeFile(file);
506 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
507 }
508
509 // Test: test-kind=api, api=InspectApiImpl::literalGetU8, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU8_3)510 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU8_3)
511 {
512 AbckitFile *file = nullptr;
513 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
514 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
515 auto val = g_implI->literalGetU8(res);
516 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
517 ASSERT_EQ(val, 0);
518 // Write output file
519 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
520 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
521 g_impl->closeFile(file);
522 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
523 }
524
525 // Test: test-kind=api, api=InspectApiImpl::literalGetU8, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU8_4)526 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU8_4)
527 {
528 AbckitFile *file = nullptr;
529 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
530 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
531 auto val = g_implI->literalGetU8(res);
532 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
533 ASSERT_EQ(val, 0);
534 // Write output file
535 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
536 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
537 g_impl->closeFile(file);
538 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
539 }
540
541 // Test: test-kind=api, api=InspectApiImpl::literalGetU16, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU16_3)542 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU16_3)
543 {
544 AbckitFile *file = nullptr;
545 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
546 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
547 auto val = g_implI->literalGetU16(res);
548 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
549 ASSERT_EQ(val, 0);
550 // Write output file
551 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
552 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
553 g_impl->closeFile(file);
554 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
555 }
556
557 // Test: test-kind=api, api=InspectApiImpl::literalGetU16, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU16_4)558 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU16_4)
559 {
560 AbckitFile *file = nullptr;
561 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
562 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
563 auto val = g_implI->literalGetU16(res);
564 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
565 ASSERT_EQ(val, 0);
566 // Write output file
567 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
568 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
569 g_impl->closeFile(file);
570 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
571 }
572
573 // Test: test-kind=api, api=InspectApiImpl::literalGetMethodAffiliate, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetMethodAffiliate_3)574 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetMethodAffiliate_3)
575 {
576 AbckitFile *file = nullptr;
577 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
578 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
579 auto val = g_implI->literalGetMethodAffiliate(res);
580 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
581 ASSERT_EQ(val, 0);
582 // Write output file
583 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
584 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
585 g_impl->closeFile(file);
586 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
587 }
588
589 // Test: test-kind=api, api=InspectApiImpl::literalGetMethodAffiliate, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetMethodAffiliate_4)590 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetMethodAffiliate_4)
591 {
592 AbckitFile *file = nullptr;
593 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
594 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
595 auto val = g_implI->literalGetMethodAffiliate(res);
596 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
597 ASSERT_EQ(val, 0);
598 // Write output file
599 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
600 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
601 g_impl->closeFile(file);
602 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
603 }
604
605 // Test: test-kind=api, api=InspectApiImpl::literalGetU32, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU32_3)606 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU32_3)
607 {
608 AbckitFile *file = nullptr;
609 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
610 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
611 auto val = g_implI->literalGetU32(res);
612 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
613 ASSERT_EQ(val, 0);
614 // Write output file
615 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
616 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
617 g_impl->closeFile(file);
618 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
619 }
620
621 // Test: test-kind=api, api=InspectApiImpl::literalGetU32, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU32_4)622 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU32_4)
623 {
624 AbckitFile *file = nullptr;
625 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
626 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
627 auto val = g_implI->literalGetU32(res);
628 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
629 ASSERT_EQ(val, 0);
630 // Write output file
631 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
632 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
633 g_impl->closeFile(file);
634 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
635 }
636
637 // Test: test-kind=api, api=InspectApiImpl::literalGetU64, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU64_3)638 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU64_3)
639 {
640 AbckitFile *file = nullptr;
641 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
642 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
643 auto val = g_implI->literalGetU64(res);
644 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
645 ASSERT_EQ(val, 0);
646 // Write output file
647 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
648 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
649 g_impl->closeFile(file);
650 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
651 }
652
653 // Test: test-kind=api, api=InspectApiImpl::literalGetU64, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetU64_4)654 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetU64_4)
655 {
656 AbckitFile *file = nullptr;
657 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
658 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
659 auto val = g_implI->literalGetU64(res);
660 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
661 ASSERT_EQ(val, 0);
662 // Write output file
663 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
664 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
665 g_impl->closeFile(file);
666 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
667 }
668
669 // Test: test-kind=api, api=InspectApiImpl::literalGetFloat, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetFloat_3)670 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetFloat_3)
671 {
672 AbckitFile *file = nullptr;
673 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
674 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
675 auto val = g_implI->literalGetFloat(res);
676 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
677 ASSERT_FLOAT_EQ(val, 0);
678 // Write output file
679 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
680 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
681 g_impl->closeFile(file);
682 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
683 }
684
685 // Test: test-kind=api, api=InspectApiImpl::literalGetFloat, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetFloat_4)686 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetFloat_4)
687 {
688 AbckitFile *file = nullptr;
689 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
690 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
691 auto val = g_implI->literalGetFloat(res);
692 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
693 ASSERT_FLOAT_EQ(val, 0);
694 // Write output file
695 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
696 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
697 g_impl->closeFile(file);
698 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
699 }
700
701 // Test: test-kind=api, api=InspectApiImpl::literalGetDouble, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetDouble_3)702 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetDouble_3)
703 {
704 AbckitFile *file = nullptr;
705 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
706 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
707 auto val = g_implI->literalGetDouble(res);
708 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
709 ASSERT_DOUBLE_EQ(val, 0);
710 // Write output file
711 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
712 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
713 g_impl->closeFile(file);
714 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
715 }
716
717 // Test: test-kind=api, api=InspectApiImpl::literalGetDouble, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetDouble_4)718 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetDouble_4)
719 {
720 AbckitFile *file = nullptr;
721 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
722 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
723 auto val = g_implI->literalGetDouble(res);
724 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
725 ASSERT_DOUBLE_EQ(val, 0);
726 // Write output file
727 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
728 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
729 g_impl->closeFile(file);
730 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
731 }
732
733 // Test: test-kind=api, api=InspectApiImpl::literalGetLiteralArray, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetLiteralArray_3)734 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetLiteralArray_3)
735 {
736 AbckitFile *file = nullptr;
737 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
738 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
739 auto val = g_implI->literalGetLiteralArray(res);
740 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
741 ASSERT_EQ(val, nullptr);
742 // Write output file
743 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
744 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
745 g_impl->closeFile(file);
746 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
747 }
748
749 // Test: test-kind=api, api=InspectApiImpl::literalGetLiteralArray, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetLiteralArray_4)750 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetLiteralArray_4)
751 {
752 AbckitFile *file = nullptr;
753 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
754 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
755 auto val = g_implI->literalGetLiteralArray(res);
756 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_UNSUPPORTED);
757 ASSERT_EQ(val, nullptr);
758 // Write output file
759 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
760 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
761 g_impl->closeFile(file);
762 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
763 }
764
765 // Test: test-kind=api, api=InspectApiImpl::literalGetString, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetString_3)766 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetString_3)
767 {
768 AbckitFile *file = nullptr;
769 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
770 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
771 auto val = g_implI->literalGetString(res);
772 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
773 ASSERT_EQ(val, nullptr);
774 // Write output file
775 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
776 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
777 g_impl->closeFile(file);
778 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
779 }
780
781 // Test: test-kind=api, api=InspectApiImpl::literalGetString, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetString_4)782 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetString_4)
783 {
784 AbckitFile *file = nullptr;
785 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
786 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
787 auto val = g_implI->literalGetString(res);
788 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
789 ASSERT_EQ(val, nullptr);
790 // Write output file
791 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
792 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
793 g_impl->closeFile(file);
794 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
795 }
796
797 // Test: test-kind=api, api=InspectApiImpl::literalGetMethod, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetMethod_3)798 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetMethod_3)
799 {
800 AbckitFile *file = nullptr;
801 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_dynamic.abc", &file);
802 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
803 auto val = g_implI->literalGetMethod(res);
804 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_WRONG_LITERAL_TYPE);
805 ASSERT_EQ(val, nullptr);
806 // Write output file
807 g_impl->writeAbc(file, MODIFIED_DYNAMIC, strlen(MODIFIED_DYNAMIC));
808 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
809 g_impl->closeFile(file);
810 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
811 }
812
813 // Test: test-kind=api, api=InspectApiImpl::literalGetMethod, abc-kind=ArkTS2, category=positive, extension=c
TEST_F(LibAbcKitInspectApiLiteralsTest,LiteralGetMethod_4)814 TEST_F(LibAbcKitInspectApiLiteralsTest, LiteralGetMethod_4)
815 {
816 AbckitFile *file = nullptr;
817 helpers::AssertOpenAbc(ABCKIT_ABC_DIR "ut/metadata_core/modify_api/literals/literals_static.abc", &file);
818 AbckitLiteral *res = g_implM->createLiteralBool(file, true);
819 auto val = g_implI->literalGetMethod(res);
820 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_UNSUPPORTED);
821 ASSERT_EQ(val, nullptr);
822 // Write output file
823 g_impl->writeAbc(file, MODIFIED_STATIC, strlen(MODIFIED_STATIC));
824 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
825 g_impl->closeFile(file);
826 ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
827 }
828 } // namespace libabckit::test
829