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 "../../../include/cpp/abckit_cpp.h"
17 #include "../check_mock.h"
18 #include "../../../src/mock/mock_values.h"
19 #include "../cpp_helpers_mock.h"
20
21 #include <gtest/gtest.h>
22
23 namespace libabckit::test {
24
25 class LibAbcKitCppMockTestDynIsa : public ::testing::Test {};
26
27 // Test: test-kind=mock, api=DynamicIsa::CreateLoadString, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLoadString)28 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLoadString)
29 {
30 ASSERT_TRUE(CheckMockedStackEmpty());
31 {
32 abckit::File f(DEFAULT_PATH);
33 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
34 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLoadString(DEFAULT_CONST_CHAR);
35 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
36 ASSERT_TRUE(CheckMockedApi("IcreateLoadString"));
37 ASSERT_TRUE(CheckMockedApi("CreateString"));
38 }
39 ASSERT_TRUE(CheckMockedApi("CloseFile"));
40 ASSERT_TRUE(CheckMockedStackEmpty());
41 }
42
43 // Test: test-kind=mock, api=DynamicIsa::CreateSub2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateSub2)44 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateSub2)
45 {
46 ASSERT_TRUE(CheckMockedStackEmpty());
47 {
48 abckit::File f(DEFAULT_PATH);
49 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
50 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateSub2(abckit::mock::helpers::GetMockInstruction(f),
51 abckit::mock::helpers::GetMockInstruction(f));
52 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
53 ASSERT_TRUE(CheckMockedApi("IcreateSub2"));
54 }
55 ASSERT_TRUE(CheckMockedApi("CloseFile"));
56 ASSERT_TRUE(CheckMockedStackEmpty());
57 }
58
59 // Test: test-kind=mock, api=DynamicIsa::GetModule, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_GetModule)60 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_GetModule)
61 {
62 ASSERT_TRUE(CheckMockedStackEmpty());
63 {
64 abckit::File f(DEFAULT_PATH);
65 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
66 abckit::mock::helpers::GetMockGraph(f).DynIsa().GetModule(abckit::mock::helpers::GetMockInstruction(f));
67 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
68 ASSERT_TRUE(CheckMockedApi("IgetModule"));
69 }
70 ASSERT_TRUE(CheckMockedApi("CloseFile"));
71 ASSERT_TRUE(CheckMockedStackEmpty());
72 }
73
74 // Test: test-kind=mock, api=DynamicIsa::SetModule, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_SetModule)75 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_SetModule)
76 {
77 ASSERT_TRUE(CheckMockedStackEmpty());
78 {
79 abckit::File f(DEFAULT_PATH);
80 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
81 abckit::mock::helpers::GetMockGraph(f).DynIsa().SetModule(abckit::mock::helpers::GetMockInstruction(f),
82 abckit::mock::helpers::GetMockCoreModule(f));
83 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
84 ASSERT_TRUE(CheckMockedApi("IsetModule"));
85 }
86 ASSERT_TRUE(CheckMockedApi("CloseFile"));
87 ASSERT_TRUE(CheckMockedStackEmpty());
88 }
89
90 // Test: test-kind=mock, api=DynamicIsa::GetConditionCode, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_GetConditionCode)91 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_GetConditionCode)
92 {
93 ASSERT_TRUE(CheckMockedStackEmpty());
94 {
95 abckit::File f(DEFAULT_PATH);
96 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
97 abckit::mock::helpers::GetMockGraph(f).DynIsa().GetConditionCode(abckit::mock::helpers::GetMockInstruction(f));
98 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
99 ASSERT_TRUE(CheckMockedApi("IgetConditionCode"));
100 }
101 ASSERT_TRUE(CheckMockedApi("CloseFile"));
102 ASSERT_TRUE(CheckMockedStackEmpty());
103 }
104
105 // Test: test-kind=mock, api=DynamicIsa::SetConditionCode, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_SetConditionCode)106 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_SetConditionCode)
107 {
108 ASSERT_TRUE(CheckMockedStackEmpty());
109 {
110 abckit::File f(DEFAULT_PATH);
111 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
112 abckit::mock::helpers::GetMockGraph(f).DynIsa().SetConditionCode(abckit::mock::helpers::GetMockInstruction(f),
113 DEFAULT_ENUM_ISA_DYNAMIC_CONDITION_TYPE);
114 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
115 ASSERT_TRUE(CheckMockedApi("IsetConditionCode"));
116 }
117 ASSERT_TRUE(CheckMockedApi("CloseFile"));
118 ASSERT_TRUE(CheckMockedStackEmpty());
119 }
120
121 // Test: test-kind=mock, api=DynamicIsa::GetOpcode, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_GetOpcode)122 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_GetOpcode)
123 {
124 ASSERT_TRUE(CheckMockedStackEmpty());
125 {
126 abckit::File f(DEFAULT_PATH);
127 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
128 abckit::mock::helpers::GetMockGraph(f).DynIsa().GetOpcode(abckit::mock::helpers::GetMockInstruction(f));
129 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
130 ASSERT_TRUE(CheckMockedApi("IgetOpcode"));
131 }
132 ASSERT_TRUE(CheckMockedApi("CloseFile"));
133 ASSERT_TRUE(CheckMockedStackEmpty());
134 }
135
136 // Test: test-kind=mock, api=DynamicIsa::GetImportDescriptor, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_GetImportDescriptor)137 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_GetImportDescriptor)
138 {
139 ASSERT_TRUE(CheckMockedStackEmpty());
140 {
141 abckit::File f(DEFAULT_PATH);
142 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
143 abckit::mock::helpers::GetMockGraph(f).DynIsa().GetImportDescriptor(
144 abckit::mock::helpers::GetMockInstruction(f));
145 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
146 ASSERT_TRUE(CheckMockedApi("IgetImportDescriptor"));
147 }
148 ASSERT_TRUE(CheckMockedApi("CloseFile"));
149 ASSERT_TRUE(CheckMockedStackEmpty());
150 }
151
152 // Test: test-kind=mock, api=DynamicIsa::SetImportDescriptor, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_SetImportDescriptor)153 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_SetImportDescriptor)
154 {
155 ASSERT_TRUE(CheckMockedStackEmpty());
156 {
157 abckit::File f(DEFAULT_PATH);
158 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
159 abckit::mock::helpers::GetMockGraph(f).DynIsa().SetImportDescriptor(
160 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockCoreImportDescriptor(f));
161 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
162 ASSERT_TRUE(CheckMockedApi("IsetImportDescriptor"));
163 }
164 ASSERT_TRUE(CheckMockedApi("CloseFile"));
165 ASSERT_TRUE(CheckMockedStackEmpty());
166 }
167
168 // Test: test-kind=mock, api=DynamicIsa::GetExportDescriptor, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_GetExportDescriptor)169 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_GetExportDescriptor)
170 {
171 ASSERT_TRUE(CheckMockedStackEmpty());
172 {
173 abckit::File f(DEFAULT_PATH);
174 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
175 abckit::mock::helpers::GetMockGraph(f).DynIsa().GetExportDescriptor(
176 abckit::mock::helpers::GetMockInstruction(f));
177 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
178 ASSERT_TRUE(CheckMockedApi("IgetExportDescriptor"));
179 }
180 ASSERT_TRUE(CheckMockedApi("CloseFile"));
181 ASSERT_TRUE(CheckMockedStackEmpty());
182 }
183
184 // Test: test-kind=mock, api=DynamicIsa::SetExportDescriptor, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_SetExportDescriptor)185 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_SetExportDescriptor)
186 {
187 ASSERT_TRUE(CheckMockedStackEmpty());
188 {
189 abckit::File f(DEFAULT_PATH);
190 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
191 abckit::mock::helpers::GetMockGraph(f).DynIsa().SetExportDescriptor(
192 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockCoreExportDescriptor(f));
193 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
194 ASSERT_TRUE(CheckMockedApi("IsetExportDescriptor"));
195 }
196 ASSERT_TRUE(CheckMockedApi("CloseFile"));
197 ASSERT_TRUE(CheckMockedStackEmpty());
198 }
199
200 // Test: test-kind=mock, api=DynamicIsa::CreateLdnan, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdnan)201 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdnan)
202 {
203 ASSERT_TRUE(CheckMockedStackEmpty());
204 {
205 abckit::File f(DEFAULT_PATH);
206 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
207 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdnan();
208 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
209 ASSERT_TRUE(CheckMockedApi("IcreateLdnan"));
210 }
211 ASSERT_TRUE(CheckMockedApi("CloseFile"));
212 ASSERT_TRUE(CheckMockedStackEmpty());
213 }
214
215 // Test: test-kind=mock, api=DynamicIsa::CreateLdinfinity, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdinfinity)216 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdinfinity)
217 {
218 ASSERT_TRUE(CheckMockedStackEmpty());
219 {
220 abckit::File f(DEFAULT_PATH);
221 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
222 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdinfinity();
223 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
224 ASSERT_TRUE(CheckMockedApi("IcreateLdinfinity"));
225 }
226 ASSERT_TRUE(CheckMockedApi("CloseFile"));
227 ASSERT_TRUE(CheckMockedStackEmpty());
228 }
229
230 // Test: test-kind=mock, api=DynamicIsa::CreateLdundefined, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdundefined)231 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdundefined)
232 {
233 ASSERT_TRUE(CheckMockedStackEmpty());
234 {
235 abckit::File f(DEFAULT_PATH);
236 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
237 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdundefined();
238 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
239 ASSERT_TRUE(CheckMockedApi("IcreateLdundefined"));
240 }
241 ASSERT_TRUE(CheckMockedApi("CloseFile"));
242 ASSERT_TRUE(CheckMockedStackEmpty());
243 }
244
245 // Test: test-kind=mock, api=DynamicIsa::CreateLdnull, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdnull)246 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdnull)
247 {
248 ASSERT_TRUE(CheckMockedStackEmpty());
249 {
250 abckit::File f(DEFAULT_PATH);
251 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
252 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdnull();
253 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
254 ASSERT_TRUE(CheckMockedApi("IcreateLdnull"));
255 }
256 ASSERT_TRUE(CheckMockedApi("CloseFile"));
257 ASSERT_TRUE(CheckMockedStackEmpty());
258 }
259
260 // Test: test-kind=mock, api=DynamicIsa::CreateLdsymbol, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdsymbol)261 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdsymbol)
262 {
263 ASSERT_TRUE(CheckMockedStackEmpty());
264 {
265 abckit::File f(DEFAULT_PATH);
266 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
267 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdsymbol();
268 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
269 ASSERT_TRUE(CheckMockedApi("IcreateLdsymbol"));
270 }
271 ASSERT_TRUE(CheckMockedApi("CloseFile"));
272 ASSERT_TRUE(CheckMockedStackEmpty());
273 }
274
275 // Test: test-kind=mock, api=DynamicIsa::CreateLdglobal, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdglobal)276 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdglobal)
277 {
278 ASSERT_TRUE(CheckMockedStackEmpty());
279 {
280 abckit::File f(DEFAULT_PATH);
281 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
282 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdglobal();
283 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
284 ASSERT_TRUE(CheckMockedApi("IcreateLdglobal"));
285 }
286 ASSERT_TRUE(CheckMockedApi("CloseFile"));
287 ASSERT_TRUE(CheckMockedStackEmpty());
288 }
289
290 // Test: test-kind=mock, api=DynamicIsa::CreateLdtrue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdtrue)291 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdtrue)
292 {
293 ASSERT_TRUE(CheckMockedStackEmpty());
294 {
295 abckit::File f(DEFAULT_PATH);
296 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
297 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdtrue();
298 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
299 ASSERT_TRUE(CheckMockedApi("IcreateLdtrue"));
300 }
301 ASSERT_TRUE(CheckMockedApi("CloseFile"));
302 ASSERT_TRUE(CheckMockedStackEmpty());
303 }
304
305 // Test: test-kind=mock, api=DynamicIsa::CreateLdfalse, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdfalse)306 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdfalse)
307 {
308 ASSERT_TRUE(CheckMockedStackEmpty());
309 {
310 abckit::File f(DEFAULT_PATH);
311 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
312 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdfalse();
313 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
314 ASSERT_TRUE(CheckMockedApi("IcreateLdfalse"));
315 }
316 ASSERT_TRUE(CheckMockedApi("CloseFile"));
317 ASSERT_TRUE(CheckMockedStackEmpty());
318 }
319
320 // Test: test-kind=mock, api=DynamicIsa::CreateLdhole, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdhole)321 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdhole)
322 {
323 ASSERT_TRUE(CheckMockedStackEmpty());
324 {
325 abckit::File f(DEFAULT_PATH);
326 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
327 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdhole();
328 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
329 ASSERT_TRUE(CheckMockedApi("IcreateLdhole"));
330 }
331 ASSERT_TRUE(CheckMockedApi("CloseFile"));
332 ASSERT_TRUE(CheckMockedStackEmpty());
333 }
334
335 // Test: test-kind=mock, api=DynamicIsa::CreateLdnewtarget, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdnewtarget)336 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdnewtarget)
337 {
338 ASSERT_TRUE(CheckMockedStackEmpty());
339 {
340 abckit::File f(DEFAULT_PATH);
341 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
342 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdnewtarget();
343 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
344 ASSERT_TRUE(CheckMockedApi("IcreateLdnewtarget"));
345 }
346 ASSERT_TRUE(CheckMockedApi("CloseFile"));
347 ASSERT_TRUE(CheckMockedStackEmpty());
348 }
349
350 // Test: test-kind=mock, api=DynamicIsa::CreateLdthis, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdthis)351 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdthis)
352 {
353 ASSERT_TRUE(CheckMockedStackEmpty());
354 {
355 abckit::File f(DEFAULT_PATH);
356 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
357 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdthis();
358 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
359 ASSERT_TRUE(CheckMockedApi("IcreateLdthis"));
360 }
361 ASSERT_TRUE(CheckMockedApi("CloseFile"));
362 ASSERT_TRUE(CheckMockedStackEmpty());
363 }
364
365 // Test: test-kind=mock, api=DynamicIsa::CreatePoplexenv, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreatePoplexenv)366 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreatePoplexenv)
367 {
368 ASSERT_TRUE(CheckMockedStackEmpty());
369 {
370 abckit::File f(DEFAULT_PATH);
371 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
372 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreatePoplexenv();
373 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
374 ASSERT_TRUE(CheckMockedApi("IcreatePoplexenv"));
375 }
376 ASSERT_TRUE(CheckMockedApi("CloseFile"));
377 ASSERT_TRUE(CheckMockedStackEmpty());
378 }
379
380 // Test: test-kind=mock, api=DynamicIsa::CreateGetunmappedargs, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGetunmappedargs)381 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGetunmappedargs)
382 {
383 ASSERT_TRUE(CheckMockedStackEmpty());
384 {
385 abckit::File f(DEFAULT_PATH);
386 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
387 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGetunmappedargs();
388 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
389 ASSERT_TRUE(CheckMockedApi("IcreateGetunmappedargs"));
390 }
391 ASSERT_TRUE(CheckMockedApi("CloseFile"));
392 ASSERT_TRUE(CheckMockedStackEmpty());
393 }
394
395 // Test: test-kind=mock, api=DynamicIsa::CreateAsyncfunctionenter, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAsyncfunctionenter)396 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAsyncfunctionenter)
397 {
398 ASSERT_TRUE(CheckMockedStackEmpty());
399 {
400 abckit::File f(DEFAULT_PATH);
401 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
402 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAsyncfunctionenter();
403 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
404 ASSERT_TRUE(CheckMockedApi("IcreateAsyncfunctionenter"));
405 }
406 ASSERT_TRUE(CheckMockedApi("CloseFile"));
407 ASSERT_TRUE(CheckMockedStackEmpty());
408 }
409
410 // Test: test-kind=mock, api=DynamicIsa::CreateLdfunction, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdfunction)411 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdfunction)
412 {
413 ASSERT_TRUE(CheckMockedStackEmpty());
414 {
415 abckit::File f(DEFAULT_PATH);
416 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
417 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdfunction();
418 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
419 ASSERT_TRUE(CheckMockedApi("IcreateLdfunction"));
420 }
421 ASSERT_TRUE(CheckMockedApi("CloseFile"));
422 ASSERT_TRUE(CheckMockedStackEmpty());
423 }
424
425 // Test: test-kind=mock, api=DynamicIsa::CreateDebugger, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDebugger)426 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDebugger)
427 {
428 ASSERT_TRUE(CheckMockedStackEmpty());
429 {
430 abckit::File f(DEFAULT_PATH);
431 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
432 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDebugger();
433 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
434 ASSERT_TRUE(CheckMockedApi("IcreateDebugger"));
435 }
436 ASSERT_TRUE(CheckMockedApi("CloseFile"));
437 ASSERT_TRUE(CheckMockedStackEmpty());
438 }
439
440 // Test: test-kind=mock, api=DynamicIsa::CreateGetpropiterator, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGetpropiterator)441 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGetpropiterator)
442 {
443 ASSERT_TRUE(CheckMockedStackEmpty());
444 {
445 abckit::File f(DEFAULT_PATH);
446 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
447 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGetpropiterator(
448 abckit::mock::helpers::GetMockInstruction(f));
449 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
450 ASSERT_TRUE(CheckMockedApi("IcreateGetpropiterator"));
451 }
452 ASSERT_TRUE(CheckMockedApi("CloseFile"));
453 ASSERT_TRUE(CheckMockedStackEmpty());
454 }
455
456 // Test: test-kind=mock, api=DynamicIsa::CreateGetiterator, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGetiterator)457 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGetiterator)
458 {
459 ASSERT_TRUE(CheckMockedStackEmpty());
460 {
461 abckit::File f(DEFAULT_PATH);
462 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
463 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGetiterator(abckit::mock::helpers::GetMockInstruction(f));
464 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
465 ASSERT_TRUE(CheckMockedApi("IcreateGetiterator"));
466 }
467 ASSERT_TRUE(CheckMockedApi("CloseFile"));
468 ASSERT_TRUE(CheckMockedStackEmpty());
469 }
470
471 // Test: test-kind=mock, api=DynamicIsa::CreateGetasynciterator, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGetasynciterator)472 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGetasynciterator)
473 {
474 ASSERT_TRUE(CheckMockedStackEmpty());
475 {
476 abckit::File f(DEFAULT_PATH);
477 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
478 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGetasynciterator(
479 abckit::mock::helpers::GetMockInstruction(f));
480 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
481 ASSERT_TRUE(CheckMockedApi("IcreateGetasynciterator"));
482 }
483 ASSERT_TRUE(CheckMockedApi("CloseFile"));
484 ASSERT_TRUE(CheckMockedStackEmpty());
485 }
486
487 // Test: test-kind=mock, api=DynamicIsa::CreateLdprivateproperty, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdprivateproperty)488 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdprivateproperty)
489 {
490 ASSERT_TRUE(CheckMockedStackEmpty());
491 {
492 abckit::File f(DEFAULT_PATH);
493 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
494 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdprivateproperty(
495 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64, DEFAULT_U64);
496 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
497 ASSERT_TRUE(CheckMockedApi("IcreateLdprivateproperty"));
498 }
499 ASSERT_TRUE(CheckMockedApi("CloseFile"));
500 ASSERT_TRUE(CheckMockedStackEmpty());
501 }
502
503 // Test: test-kind=mock, api=DynamicIsa::CreateStprivateproperty, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStprivateproperty)504 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStprivateproperty)
505 {
506 ASSERT_TRUE(CheckMockedStackEmpty());
507 {
508 abckit::File f(DEFAULT_PATH);
509 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
510 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStprivateproperty(
511 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64, DEFAULT_U64,
512 abckit::mock::helpers::GetMockInstruction(f));
513 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
514 ASSERT_TRUE(CheckMockedApi("IcreateStprivateproperty"));
515 }
516 ASSERT_TRUE(CheckMockedApi("CloseFile"));
517 ASSERT_TRUE(CheckMockedStackEmpty());
518 }
519
520 // Test: test-kind=mock, api=DynamicIsa::CreateTestin, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateTestin)521 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateTestin)
522 {
523 ASSERT_TRUE(CheckMockedStackEmpty());
524 {
525 abckit::File f(DEFAULT_PATH);
526 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
527 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateTestin(abckit::mock::helpers::GetMockInstruction(f),
528 DEFAULT_U64, DEFAULT_U64);
529 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
530 ASSERT_TRUE(CheckMockedApi("IcreateTestin"));
531 }
532 ASSERT_TRUE(CheckMockedApi("CloseFile"));
533 ASSERT_TRUE(CheckMockedStackEmpty());
534 }
535
536 // Test: test-kind=mock, api=DynamicIsa::CreateDefinefieldbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDefinefieldbyname)537 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDefinefieldbyname)
538 {
539 ASSERT_TRUE(CheckMockedStackEmpty());
540 {
541 abckit::File f(DEFAULT_PATH);
542 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
543 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDefinefieldbyname(
544 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_CONST_CHAR,
545 abckit::mock::helpers::GetMockInstruction(f));
546 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
547 ASSERT_TRUE(CheckMockedApi("IcreateDefinefieldbyname"));
548 ASSERT_TRUE(CheckMockedApi("CreateString"));
549 }
550 ASSERT_TRUE(CheckMockedApi("CloseFile"));
551 ASSERT_TRUE(CheckMockedStackEmpty());
552 }
553
554 // Test: test-kind=mock, api=DynamicIsa::CreateDefinepropertybyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDefinepropertybyname)555 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDefinepropertybyname)
556 {
557 ASSERT_TRUE(CheckMockedStackEmpty());
558 {
559 abckit::File f(DEFAULT_PATH);
560 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
561 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDefinepropertybyname(
562 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_CONST_CHAR,
563 abckit::mock::helpers::GetMockInstruction(f));
564 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
565 ASSERT_TRUE(CheckMockedApi("IcreateDefinepropertybyname"));
566 ASSERT_TRUE(CheckMockedApi("CreateString"));
567 }
568 ASSERT_TRUE(CheckMockedApi("CloseFile"));
569 ASSERT_TRUE(CheckMockedStackEmpty());
570 }
571
572 // Test: test-kind=mock, api=DynamicIsa::CreateCreateemptyobject, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCreateemptyobject)573 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCreateemptyobject)
574 {
575 ASSERT_TRUE(CheckMockedStackEmpty());
576 {
577 abckit::File f(DEFAULT_PATH);
578 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
579 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCreateemptyobject();
580 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
581 ASSERT_TRUE(CheckMockedApi("IcreateCreateemptyobject"));
582 }
583 ASSERT_TRUE(CheckMockedApi("CloseFile"));
584 ASSERT_TRUE(CheckMockedStackEmpty());
585 }
586
587 // Test: test-kind=mock, api=DynamicIsa::CreateCreateemptyarray, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCreateemptyarray)588 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCreateemptyarray)
589 {
590 ASSERT_TRUE(CheckMockedStackEmpty());
591 {
592 abckit::File f(DEFAULT_PATH);
593 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
594 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCreateemptyarray();
595 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
596 ASSERT_TRUE(CheckMockedApi("IcreateCreateemptyarray"));
597 }
598 ASSERT_TRUE(CheckMockedApi("CloseFile"));
599 ASSERT_TRUE(CheckMockedStackEmpty());
600 }
601
602 // Test: test-kind=mock, api=DynamicIsa::CreateCreategeneratorobj, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCreategeneratorobj)603 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCreategeneratorobj)
604 {
605 ASSERT_TRUE(CheckMockedStackEmpty());
606 {
607 abckit::File f(DEFAULT_PATH);
608 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
609 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCreategeneratorobj(
610 abckit::mock::helpers::GetMockInstruction(f));
611 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
612 ASSERT_TRUE(CheckMockedApi("IcreateCreategeneratorobj"));
613 }
614 ASSERT_TRUE(CheckMockedApi("CloseFile"));
615 ASSERT_TRUE(CheckMockedStackEmpty());
616 }
617
618 // Test: test-kind=mock, api=DynamicIsa::CreateCreateiterresultobj, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCreateiterresultobj)619 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCreateiterresultobj)
620 {
621 ASSERT_TRUE(CheckMockedStackEmpty());
622 {
623 abckit::File f(DEFAULT_PATH);
624 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
625 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCreateiterresultobj(
626 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
627 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
628 ASSERT_TRUE(CheckMockedApi("IcreateCreateiterresultobj"));
629 }
630 ASSERT_TRUE(CheckMockedApi("CloseFile"));
631 ASSERT_TRUE(CheckMockedStackEmpty());
632 }
633
634 // Test: test-kind=mock, api=DynamicIsa::CreateCreateobjectwithexcludedkeys, abc-kind=ArkTS1, category=internal,
635 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCreateobjectwithexcludedkeys)636 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCreateobjectwithexcludedkeys)
637 {
638 ASSERT_TRUE(CheckMockedStackEmpty());
639 {
640 abckit::File f(DEFAULT_PATH);
641 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
642 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCreateobjectwithexcludedkeys(
643 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64,
644 abckit::mock::helpers::GetMockInstruction(f));
645 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
646 ASSERT_TRUE(CheckMockedApi("IcreateCreateobjectwithexcludedkeys"));
647 }
648 ASSERT_TRUE(CheckMockedApi("CloseFile"));
649 ASSERT_TRUE(CheckMockedStackEmpty());
650 }
651
652 // Test: test-kind=mock, api=DynamicIsa::CreateWideCreateobjectwithexcludedkeys, abc-kind=ArkTS1, category=internal,
653 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideCreateobjectwithexcludedkeys)654 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideCreateobjectwithexcludedkeys)
655 {
656 ASSERT_TRUE(CheckMockedStackEmpty());
657 {
658 abckit::File f(DEFAULT_PATH);
659 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
660 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideCreateobjectwithexcludedkeys(
661 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64,
662 abckit::mock::helpers::GetMockInstruction(f));
663 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
664 ASSERT_TRUE(CheckMockedApi("IcreateWideCreateobjectwithexcludedkeys"));
665 }
666 ASSERT_TRUE(CheckMockedApi("CloseFile"));
667 ASSERT_TRUE(CheckMockedStackEmpty());
668 }
669
670 // Test: test-kind=mock, api=DynamicIsa::CreateCreatearraywithbuffer, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCreatearraywithbuffer)671 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCreatearraywithbuffer)
672 {
673 ASSERT_TRUE(CheckMockedStackEmpty());
674 {
675 abckit::File f(DEFAULT_PATH);
676 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
677 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCreatearraywithbuffer(
678 abckit::mock::helpers::GetMockLiteralArray(f));
679 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
680 ASSERT_TRUE(CheckMockedApi("IcreateCreatearraywithbuffer"));
681 }
682 ASSERT_TRUE(CheckMockedApi("CloseFile"));
683 ASSERT_TRUE(CheckMockedStackEmpty());
684 }
685
686 // Test: test-kind=mock, api=DynamicIsa::CreateCreateobjectwithbuffer, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCreateobjectwithbuffer)687 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCreateobjectwithbuffer)
688 {
689 ASSERT_TRUE(CheckMockedStackEmpty());
690 {
691 abckit::File f(DEFAULT_PATH);
692 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
693 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCreateobjectwithbuffer(
694 abckit::mock::helpers::GetMockLiteralArray(f));
695 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
696 ASSERT_TRUE(CheckMockedApi("IcreateCreateobjectwithbuffer"));
697 }
698 ASSERT_TRUE(CheckMockedApi("CloseFile"));
699 ASSERT_TRUE(CheckMockedStackEmpty());
700 }
701
702 // Test: test-kind=mock, api=DynamicIsa::CreateNewobjapply, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateNewobjapply)703 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateNewobjapply)
704 {
705 ASSERT_TRUE(CheckMockedStackEmpty());
706 {
707 abckit::File f(DEFAULT_PATH);
708 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
709 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateNewobjapply(abckit::mock::helpers::GetMockInstruction(f),
710 abckit::mock::helpers::GetMockInstruction(f));
711 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
712 ASSERT_TRUE(CheckMockedApi("IcreateNewobjapply"));
713 }
714 ASSERT_TRUE(CheckMockedApi("CloseFile"));
715 ASSERT_TRUE(CheckMockedStackEmpty());
716 }
717
718 // Test: test-kind=mock, api=DynamicIsa::CreateNewobjrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateNewobjrange)719 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateNewobjrange)
720 {
721 ASSERT_TRUE(CheckMockedStackEmpty());
722 {
723 abckit::File f(DEFAULT_PATH);
724 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
725 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateNewobjrange(abckit::mock::helpers::GetMockInstruction(f),
726 abckit::mock::helpers::GetMockInstruction(f));
727 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
728 ASSERT_TRUE(CheckMockedApi("IcreateNewobjrange"));
729 }
730 ASSERT_TRUE(CheckMockedApi("CloseFile"));
731 ASSERT_TRUE(CheckMockedStackEmpty());
732 }
733
734 // Test: test-kind=mock, api=DynamicIsa::CreateWideNewobjrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideNewobjrange)735 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideNewobjrange)
736 {
737 ASSERT_TRUE(CheckMockedStackEmpty());
738 {
739 abckit::File f(DEFAULT_PATH);
740 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
741 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideNewobjrange(
742 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
743 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
744 ASSERT_TRUE(CheckMockedApi("IcreateWideNewobjrange"));
745 }
746 ASSERT_TRUE(CheckMockedApi("CloseFile"));
747 ASSERT_TRUE(CheckMockedStackEmpty());
748 }
749
750 // Test: test-kind=mock, api=DynamicIsa::CreateNewlexenv, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateNewlexenv)751 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateNewlexenv)
752 {
753 ASSERT_TRUE(CheckMockedStackEmpty());
754 {
755 abckit::File f(DEFAULT_PATH);
756 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
757 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateNewlexenv(DEFAULT_U64);
758 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
759 ASSERT_TRUE(CheckMockedApi("IcreateNewlexenv"));
760 }
761 ASSERT_TRUE(CheckMockedApi("CloseFile"));
762 ASSERT_TRUE(CheckMockedStackEmpty());
763 }
764
765 // Test: test-kind=mock, api=DynamicIsa::CreateWideNewlexenv, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideNewlexenv)766 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideNewlexenv)
767 {
768 ASSERT_TRUE(CheckMockedStackEmpty());
769 {
770 abckit::File f(DEFAULT_PATH);
771 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
772 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideNewlexenv(DEFAULT_U64);
773 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
774 ASSERT_TRUE(CheckMockedApi("IcreateWideNewlexenv"));
775 }
776 ASSERT_TRUE(CheckMockedApi("CloseFile"));
777 ASSERT_TRUE(CheckMockedStackEmpty());
778 }
779
780 // Test: test-kind=mock, api=DynamicIsa::CreateNewlexenvwithname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateNewlexenvwithname)781 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateNewlexenvwithname)
782 {
783 ASSERT_TRUE(CheckMockedStackEmpty());
784 {
785 abckit::File f(DEFAULT_PATH);
786 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
787 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateNewlexenvwithname(
788 DEFAULT_U64, abckit::mock::helpers::GetMockLiteralArray(f));
789 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
790 ASSERT_TRUE(CheckMockedApi("IcreateNewlexenvwithname"));
791 }
792 ASSERT_TRUE(CheckMockedApi("CloseFile"));
793 ASSERT_TRUE(CheckMockedStackEmpty());
794 }
795
796 // Test: test-kind=mock, api=DynamicIsa::CreateWideNewlexenvwithname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideNewlexenvwithname)797 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideNewlexenvwithname)
798 {
799 ASSERT_TRUE(CheckMockedStackEmpty());
800 {
801 abckit::File f(DEFAULT_PATH);
802 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
803 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideNewlexenvwithname(
804 DEFAULT_U64, abckit::mock::helpers::GetMockLiteralArray(f));
805 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
806 ASSERT_TRUE(CheckMockedApi("IcreateWideNewlexenvwithname"));
807 }
808 ASSERT_TRUE(CheckMockedApi("CloseFile"));
809 ASSERT_TRUE(CheckMockedStackEmpty());
810 }
811
812 // Test: test-kind=mock, api=DynamicIsa::CreateCreateasyncgeneratorobj, abc-kind=ArkTS1, category=internal,
813 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCreateasyncgeneratorobj)814 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCreateasyncgeneratorobj)
815 {
816 ASSERT_TRUE(CheckMockedStackEmpty());
817 {
818 abckit::File f(DEFAULT_PATH);
819 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
820 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCreateasyncgeneratorobj(
821 abckit::mock::helpers::GetMockInstruction(f));
822 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
823 ASSERT_TRUE(CheckMockedApi("IcreateCreateasyncgeneratorobj"));
824 }
825 ASSERT_TRUE(CheckMockedApi("CloseFile"));
826 ASSERT_TRUE(CheckMockedStackEmpty());
827 }
828
829 // Test: test-kind=mock, api=DynamicIsa::CreateAsyncgeneratorresolve, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAsyncgeneratorresolve)830 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAsyncgeneratorresolve)
831 {
832 ASSERT_TRUE(CheckMockedStackEmpty());
833 {
834 abckit::File f(DEFAULT_PATH);
835 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
836 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAsyncgeneratorresolve(
837 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
838 abckit::mock::helpers::GetMockInstruction(f));
839 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
840 ASSERT_TRUE(CheckMockedApi("IcreateAsyncgeneratorresolve"));
841 }
842 ASSERT_TRUE(CheckMockedApi("CloseFile"));
843 ASSERT_TRUE(CheckMockedStackEmpty());
844 }
845
846 // Test: test-kind=mock, api=DynamicIsa::CreateAdd2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAdd2)847 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAdd2)
848 {
849 ASSERT_TRUE(CheckMockedStackEmpty());
850 {
851 abckit::File f(DEFAULT_PATH);
852 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
853 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAdd2(abckit::mock::helpers::GetMockInstruction(f),
854 abckit::mock::helpers::GetMockInstruction(f));
855 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
856 ASSERT_TRUE(CheckMockedApi("IcreateAdd2"));
857 }
858 ASSERT_TRUE(CheckMockedApi("CloseFile"));
859 ASSERT_TRUE(CheckMockedStackEmpty());
860 }
861
862 // Test: test-kind=mock, api=DynamicIsa::CreateMul2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateMul2)863 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateMul2)
864 {
865 ASSERT_TRUE(CheckMockedStackEmpty());
866 {
867 abckit::File f(DEFAULT_PATH);
868 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
869 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateMul2(abckit::mock::helpers::GetMockInstruction(f),
870 abckit::mock::helpers::GetMockInstruction(f));
871 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
872 ASSERT_TRUE(CheckMockedApi("IcreateMul2"));
873 }
874 ASSERT_TRUE(CheckMockedApi("CloseFile"));
875 ASSERT_TRUE(CheckMockedStackEmpty());
876 }
877
878 // Test: test-kind=mock, api=DynamicIsa::CreateDiv2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDiv2)879 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDiv2)
880 {
881 ASSERT_TRUE(CheckMockedStackEmpty());
882 {
883 abckit::File f(DEFAULT_PATH);
884 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
885 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDiv2(abckit::mock::helpers::GetMockInstruction(f),
886 abckit::mock::helpers::GetMockInstruction(f));
887 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
888 ASSERT_TRUE(CheckMockedApi("IcreateDiv2"));
889 }
890 ASSERT_TRUE(CheckMockedApi("CloseFile"));
891 ASSERT_TRUE(CheckMockedStackEmpty());
892 }
893
894 // Test: test-kind=mock, api=DynamicIsa::CreateMod2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateMod2)895 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateMod2)
896 {
897 ASSERT_TRUE(CheckMockedStackEmpty());
898 {
899 abckit::File f(DEFAULT_PATH);
900 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
901 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateMod2(abckit::mock::helpers::GetMockInstruction(f),
902 abckit::mock::helpers::GetMockInstruction(f));
903 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
904 ASSERT_TRUE(CheckMockedApi("IcreateMod2"));
905 }
906 ASSERT_TRUE(CheckMockedApi("CloseFile"));
907 ASSERT_TRUE(CheckMockedStackEmpty());
908 }
909
910 // Test: test-kind=mock, api=DynamicIsa::CreateEq, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateEq)911 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateEq)
912 {
913 ASSERT_TRUE(CheckMockedStackEmpty());
914 {
915 abckit::File f(DEFAULT_PATH);
916 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
917 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateEq(abckit::mock::helpers::GetMockInstruction(f),
918 abckit::mock::helpers::GetMockInstruction(f));
919 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
920 ASSERT_TRUE(CheckMockedApi("IcreateEq"));
921 }
922 ASSERT_TRUE(CheckMockedApi("CloseFile"));
923 ASSERT_TRUE(CheckMockedStackEmpty());
924 }
925
926 // Test: test-kind=mock, api=DynamicIsa::CreateNoteq, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateNoteq)927 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateNoteq)
928 {
929 ASSERT_TRUE(CheckMockedStackEmpty());
930 {
931 abckit::File f(DEFAULT_PATH);
932 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
933 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateNoteq(abckit::mock::helpers::GetMockInstruction(f),
934 abckit::mock::helpers::GetMockInstruction(f));
935 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
936 ASSERT_TRUE(CheckMockedApi("IcreateNoteq"));
937 }
938 ASSERT_TRUE(CheckMockedApi("CloseFile"));
939 ASSERT_TRUE(CheckMockedStackEmpty());
940 }
941
942 // Test: test-kind=mock, api=DynamicIsa::CreateLess, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLess)943 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLess)
944 {
945 ASSERT_TRUE(CheckMockedStackEmpty());
946 {
947 abckit::File f(DEFAULT_PATH);
948 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
949 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLess(abckit::mock::helpers::GetMockInstruction(f),
950 abckit::mock::helpers::GetMockInstruction(f));
951 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
952 ASSERT_TRUE(CheckMockedApi("IcreateLess"));
953 }
954 ASSERT_TRUE(CheckMockedApi("CloseFile"));
955 ASSERT_TRUE(CheckMockedStackEmpty());
956 }
957
958 // Test: test-kind=mock, api=DynamicIsa::CreateLesseq, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLesseq)959 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLesseq)
960 {
961 ASSERT_TRUE(CheckMockedStackEmpty());
962 {
963 abckit::File f(DEFAULT_PATH);
964 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
965 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLesseq(abckit::mock::helpers::GetMockInstruction(f),
966 abckit::mock::helpers::GetMockInstruction(f));
967 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
968 ASSERT_TRUE(CheckMockedApi("IcreateLesseq"));
969 }
970 ASSERT_TRUE(CheckMockedApi("CloseFile"));
971 ASSERT_TRUE(CheckMockedStackEmpty());
972 }
973
974 // Test: test-kind=mock, api=DynamicIsa::CreateGreater, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGreater)975 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGreater)
976 {
977 ASSERT_TRUE(CheckMockedStackEmpty());
978 {
979 abckit::File f(DEFAULT_PATH);
980 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
981 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGreater(abckit::mock::helpers::GetMockInstruction(f),
982 abckit::mock::helpers::GetMockInstruction(f));
983 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
984 ASSERT_TRUE(CheckMockedApi("IcreateGreater"));
985 }
986 ASSERT_TRUE(CheckMockedApi("CloseFile"));
987 ASSERT_TRUE(CheckMockedStackEmpty());
988 }
989
990 // Test: test-kind=mock, api=DynamicIsa::CreateGreatereq, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGreatereq)991 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGreatereq)
992 {
993 ASSERT_TRUE(CheckMockedStackEmpty());
994 {
995 abckit::File f(DEFAULT_PATH);
996 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
997 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGreatereq(abckit::mock::helpers::GetMockInstruction(f),
998 abckit::mock::helpers::GetMockInstruction(f));
999 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1000 ASSERT_TRUE(CheckMockedApi("IcreateGreatereq"));
1001 }
1002 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1003 ASSERT_TRUE(CheckMockedStackEmpty());
1004 }
1005
1006 // Test: test-kind=mock, api=DynamicIsa::CreateShl2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateShl2)1007 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateShl2)
1008 {
1009 ASSERT_TRUE(CheckMockedStackEmpty());
1010 {
1011 abckit::File f(DEFAULT_PATH);
1012 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1013 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateShl2(abckit::mock::helpers::GetMockInstruction(f),
1014 abckit::mock::helpers::GetMockInstruction(f));
1015 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1016 ASSERT_TRUE(CheckMockedApi("IcreateShl2"));
1017 }
1018 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1019 ASSERT_TRUE(CheckMockedStackEmpty());
1020 }
1021
1022 // Test: test-kind=mock, api=DynamicIsa::CreateShr2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateShr2)1023 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateShr2)
1024 {
1025 ASSERT_TRUE(CheckMockedStackEmpty());
1026 {
1027 abckit::File f(DEFAULT_PATH);
1028 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1029 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateShr2(abckit::mock::helpers::GetMockInstruction(f),
1030 abckit::mock::helpers::GetMockInstruction(f));
1031 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1032 ASSERT_TRUE(CheckMockedApi("IcreateShr2"));
1033 }
1034 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1035 ASSERT_TRUE(CheckMockedStackEmpty());
1036 }
1037
1038 // Test: test-kind=mock, api=DynamicIsa::CreateAshr2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAshr2)1039 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAshr2)
1040 {
1041 ASSERT_TRUE(CheckMockedStackEmpty());
1042 {
1043 abckit::File f(DEFAULT_PATH);
1044 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1045 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAshr2(abckit::mock::helpers::GetMockInstruction(f),
1046 abckit::mock::helpers::GetMockInstruction(f));
1047 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1048 ASSERT_TRUE(CheckMockedApi("IcreateAshr2"));
1049 }
1050 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1051 ASSERT_TRUE(CheckMockedStackEmpty());
1052 }
1053
1054 // Test: test-kind=mock, api=DynamicIsa::CreateAnd2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAnd2)1055 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAnd2)
1056 {
1057 ASSERT_TRUE(CheckMockedStackEmpty());
1058 {
1059 abckit::File f(DEFAULT_PATH);
1060 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1061 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAnd2(abckit::mock::helpers::GetMockInstruction(f),
1062 abckit::mock::helpers::GetMockInstruction(f));
1063 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1064 ASSERT_TRUE(CheckMockedApi("IcreateAnd2"));
1065 }
1066 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1067 ASSERT_TRUE(CheckMockedStackEmpty());
1068 }
1069
1070 // Test: test-kind=mock, api=DynamicIsa::CreateOr2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateOr2)1071 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateOr2)
1072 {
1073 ASSERT_TRUE(CheckMockedStackEmpty());
1074 {
1075 abckit::File f(DEFAULT_PATH);
1076 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1077 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateOr2(abckit::mock::helpers::GetMockInstruction(f),
1078 abckit::mock::helpers::GetMockInstruction(f));
1079 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1080 ASSERT_TRUE(CheckMockedApi("IcreateOr2"));
1081 }
1082 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1083 ASSERT_TRUE(CheckMockedStackEmpty());
1084 }
1085
1086 // Test: test-kind=mock, api=DynamicIsa::CreateXor2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateXor2)1087 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateXor2)
1088 {
1089 ASSERT_TRUE(CheckMockedStackEmpty());
1090 {
1091 abckit::File f(DEFAULT_PATH);
1092 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1093 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateXor2(abckit::mock::helpers::GetMockInstruction(f),
1094 abckit::mock::helpers::GetMockInstruction(f));
1095 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1096 ASSERT_TRUE(CheckMockedApi("IcreateXor2"));
1097 }
1098 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1099 ASSERT_TRUE(CheckMockedStackEmpty());
1100 }
1101
1102 // Test: test-kind=mock, api=DynamicIsa::CreateExp, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateExp)1103 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateExp)
1104 {
1105 ASSERT_TRUE(CheckMockedStackEmpty());
1106 {
1107 abckit::File f(DEFAULT_PATH);
1108 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1109 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateExp(abckit::mock::helpers::GetMockInstruction(f),
1110 abckit::mock::helpers::GetMockInstruction(f));
1111 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1112 ASSERT_TRUE(CheckMockedApi("IcreateExp"));
1113 }
1114 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1115 ASSERT_TRUE(CheckMockedStackEmpty());
1116 }
1117
1118 // Test: test-kind=mock, api=DynamicIsa::CreateTypeof, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateTypeof)1119 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateTypeof)
1120 {
1121 ASSERT_TRUE(CheckMockedStackEmpty());
1122 {
1123 abckit::File f(DEFAULT_PATH);
1124 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1125 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateTypeof(abckit::mock::helpers::GetMockInstruction(f));
1126 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1127 ASSERT_TRUE(CheckMockedApi("IcreateTypeof"));
1128 }
1129 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1130 ASSERT_TRUE(CheckMockedStackEmpty());
1131 }
1132
1133 // Test: test-kind=mock, api=DynamicIsa::CreateTonumber, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateTonumber)1134 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateTonumber)
1135 {
1136 ASSERT_TRUE(CheckMockedStackEmpty());
1137 {
1138 abckit::File f(DEFAULT_PATH);
1139 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1140 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateTonumber(abckit::mock::helpers::GetMockInstruction(f));
1141 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1142 ASSERT_TRUE(CheckMockedApi("IcreateTonumber"));
1143 }
1144 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1145 ASSERT_TRUE(CheckMockedStackEmpty());
1146 }
1147
1148 // Test: test-kind=mock, api=DynamicIsa::CreateTonumeric, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateTonumeric)1149 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateTonumeric)
1150 {
1151 ASSERT_TRUE(CheckMockedStackEmpty());
1152 {
1153 abckit::File f(DEFAULT_PATH);
1154 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1155 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateTonumeric(abckit::mock::helpers::GetMockInstruction(f));
1156 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1157 ASSERT_TRUE(CheckMockedApi("IcreateTonumeric"));
1158 }
1159 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1160 ASSERT_TRUE(CheckMockedStackEmpty());
1161 }
1162
1163 // Test: test-kind=mock, api=DynamicIsa::CreateNeg, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateNeg)1164 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateNeg)
1165 {
1166 ASSERT_TRUE(CheckMockedStackEmpty());
1167 {
1168 abckit::File f(DEFAULT_PATH);
1169 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1170 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateNeg(abckit::mock::helpers::GetMockInstruction(f));
1171 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1172 ASSERT_TRUE(CheckMockedApi("IcreateNeg"));
1173 }
1174 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1175 ASSERT_TRUE(CheckMockedStackEmpty());
1176 }
1177
1178 // Test: test-kind=mock, api=DynamicIsa::CreateNot, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateNot)1179 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateNot)
1180 {
1181 ASSERT_TRUE(CheckMockedStackEmpty());
1182 {
1183 abckit::File f(DEFAULT_PATH);
1184 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1185 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateNot(abckit::mock::helpers::GetMockInstruction(f));
1186 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1187 ASSERT_TRUE(CheckMockedApi("IcreateNot"));
1188 }
1189 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1190 ASSERT_TRUE(CheckMockedStackEmpty());
1191 }
1192
1193 // Test: test-kind=mock, api=DynamicIsa::CreateInc, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateInc)1194 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateInc)
1195 {
1196 ASSERT_TRUE(CheckMockedStackEmpty());
1197 {
1198 abckit::File f(DEFAULT_PATH);
1199 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1200 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateInc(abckit::mock::helpers::GetMockInstruction(f));
1201 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1202 ASSERT_TRUE(CheckMockedApi("IcreateInc"));
1203 }
1204 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1205 ASSERT_TRUE(CheckMockedStackEmpty());
1206 }
1207
1208 // Test: test-kind=mock, api=DynamicIsa::CreateDec, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDec)1209 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDec)
1210 {
1211 ASSERT_TRUE(CheckMockedStackEmpty());
1212 {
1213 abckit::File f(DEFAULT_PATH);
1214 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1215 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDec(abckit::mock::helpers::GetMockInstruction(f));
1216 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1217 ASSERT_TRUE(CheckMockedApi("IcreateDec"));
1218 }
1219 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1220 ASSERT_TRUE(CheckMockedStackEmpty());
1221 }
1222
1223 // Test: test-kind=mock, api=DynamicIsa::CreateIstrue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateIstrue)1224 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateIstrue)
1225 {
1226 ASSERT_TRUE(CheckMockedStackEmpty());
1227 {
1228 abckit::File f(DEFAULT_PATH);
1229 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1230 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateIstrue(abckit::mock::helpers::GetMockInstruction(f));
1231 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1232 ASSERT_TRUE(CheckMockedApi("IcreateIstrue"));
1233 }
1234 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1235 ASSERT_TRUE(CheckMockedStackEmpty());
1236 }
1237
1238 // Test: test-kind=mock, api=DynamicIsa::CreateIsfalse, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateIsfalse)1239 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateIsfalse)
1240 {
1241 ASSERT_TRUE(CheckMockedStackEmpty());
1242 {
1243 abckit::File f(DEFAULT_PATH);
1244 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1245 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateIsfalse(abckit::mock::helpers::GetMockInstruction(f));
1246 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1247 ASSERT_TRUE(CheckMockedApi("IcreateIsfalse"));
1248 }
1249 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1250 ASSERT_TRUE(CheckMockedStackEmpty());
1251 }
1252
1253 // Test: test-kind=mock, api=DynamicIsa::CreateIsin, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateIsin)1254 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateIsin)
1255 {
1256 ASSERT_TRUE(CheckMockedStackEmpty());
1257 {
1258 abckit::File f(DEFAULT_PATH);
1259 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1260 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateIsin(abckit::mock::helpers::GetMockInstruction(f),
1261 abckit::mock::helpers::GetMockInstruction(f));
1262 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1263 ASSERT_TRUE(CheckMockedApi("IcreateIsin"));
1264 }
1265 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1266 ASSERT_TRUE(CheckMockedStackEmpty());
1267 }
1268
1269 // Test: test-kind=mock, api=DynamicIsa::CreateInstanceof, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateInstanceof)1270 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateInstanceof)
1271 {
1272 ASSERT_TRUE(CheckMockedStackEmpty());
1273 {
1274 abckit::File f(DEFAULT_PATH);
1275 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1276 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateInstanceof(abckit::mock::helpers::GetMockInstruction(f),
1277 abckit::mock::helpers::GetMockInstruction(f));
1278 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1279 ASSERT_TRUE(CheckMockedApi("IcreateInstanceof"));
1280 }
1281 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1282 ASSERT_TRUE(CheckMockedStackEmpty());
1283 }
1284
1285 // Test: test-kind=mock, api=DynamicIsa::CreateStrictnoteq, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStrictnoteq)1286 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStrictnoteq)
1287 {
1288 ASSERT_TRUE(CheckMockedStackEmpty());
1289 {
1290 abckit::File f(DEFAULT_PATH);
1291 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1292 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStrictnoteq(abckit::mock::helpers::GetMockInstruction(f),
1293 abckit::mock::helpers::GetMockInstruction(f));
1294 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1295 ASSERT_TRUE(CheckMockedApi("IcreateStrictnoteq"));
1296 }
1297 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1298 ASSERT_TRUE(CheckMockedStackEmpty());
1299 }
1300
1301 // Test: test-kind=mock, api=DynamicIsa::CreateStricteq, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStricteq)1302 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStricteq)
1303 {
1304 ASSERT_TRUE(CheckMockedStackEmpty());
1305 {
1306 abckit::File f(DEFAULT_PATH);
1307 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1308 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStricteq(abckit::mock::helpers::GetMockInstruction(f),
1309 abckit::mock::helpers::GetMockInstruction(f));
1310 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1311 ASSERT_TRUE(CheckMockedApi("IcreateStricteq"));
1312 }
1313 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1314 ASSERT_TRUE(CheckMockedStackEmpty());
1315 }
1316
1317 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeNotifyconcurrentresult, abc-kind=ArkTS1, category=internal,
1318 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeNotifyconcurrentresult)1319 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeNotifyconcurrentresult)
1320 {
1321 ASSERT_TRUE(CheckMockedStackEmpty());
1322 {
1323 abckit::File f(DEFAULT_PATH);
1324 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1325 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeNotifyconcurrentresult(
1326 abckit::mock::helpers::GetMockInstruction(f));
1327 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1328 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeNotifyconcurrentresult"));
1329 }
1330 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1331 ASSERT_TRUE(CheckMockedStackEmpty());
1332 }
1333
1334 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeDefinefieldbyvalue, abc-kind=ArkTS1, category=internal,
1335 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeDefinefieldbyvalue)1336 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeDefinefieldbyvalue)
1337 {
1338 ASSERT_TRUE(CheckMockedStackEmpty());
1339 {
1340 abckit::File f(DEFAULT_PATH);
1341 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1342 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeDefinefieldbyvalue(
1343 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
1344 abckit::mock::helpers::GetMockInstruction(f));
1345 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1346 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeDefinefieldbyvalue"));
1347 }
1348 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1349 ASSERT_TRUE(CheckMockedStackEmpty());
1350 }
1351
1352 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeDefinefieldbyindex, abc-kind=ArkTS1, category=internal,
1353 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeDefinefieldbyindex)1354 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeDefinefieldbyindex)
1355 {
1356 ASSERT_TRUE(CheckMockedStackEmpty());
1357 {
1358 abckit::File f(DEFAULT_PATH);
1359 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1360 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeDefinefieldbyindex(
1361 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64, abckit::mock::helpers::GetMockInstruction(f));
1362 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1363 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeDefinefieldbyindex"));
1364 }
1365 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1366 ASSERT_TRUE(CheckMockedStackEmpty());
1367 }
1368
1369 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeTopropertykey, abc-kind=ArkTS1, category=internal,
1370 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeTopropertykey)1371 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeTopropertykey)
1372 {
1373 ASSERT_TRUE(CheckMockedStackEmpty());
1374 {
1375 abckit::File f(DEFAULT_PATH);
1376 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1377 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeTopropertykey(
1378 abckit::mock::helpers::GetMockInstruction(f));
1379 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1380 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeTopropertykey"));
1381 }
1382 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1383 ASSERT_TRUE(CheckMockedStackEmpty());
1384 }
1385
1386 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeCreateprivateproperty, abc-kind=ArkTS1, category=internal,
1387 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeCreateprivateproperty)1388 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeCreateprivateproperty)
1389 {
1390 ASSERT_TRUE(CheckMockedStackEmpty());
1391 {
1392 abckit::File f(DEFAULT_PATH);
1393 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1394 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeCreateprivateproperty(
1395 DEFAULT_U64, abckit::mock::helpers::GetMockLiteralArray(f));
1396 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1397 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeCreateprivateproperty"));
1398 }
1399 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1400 ASSERT_TRUE(CheckMockedStackEmpty());
1401 }
1402
1403 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeDefineprivateproperty, abc-kind=ArkTS1, category=internal,
1404 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeDefineprivateproperty)1405 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeDefineprivateproperty)
1406 {
1407 ASSERT_TRUE(CheckMockedStackEmpty());
1408 {
1409 abckit::File f(DEFAULT_PATH);
1410 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1411 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeDefineprivateproperty(
1412 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64, DEFAULT_U64,
1413 abckit::mock::helpers::GetMockInstruction(f));
1414 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1415 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeDefineprivateproperty"));
1416 }
1417 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1418 ASSERT_TRUE(CheckMockedStackEmpty());
1419 }
1420
1421 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeCallinit, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeCallinit)1422 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeCallinit)
1423 {
1424 ASSERT_TRUE(CheckMockedStackEmpty());
1425 {
1426 abckit::File f(DEFAULT_PATH);
1427 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1428 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeCallinit(
1429 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
1430 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1431 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeCallinit"));
1432 }
1433 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1434 ASSERT_TRUE(CheckMockedStackEmpty());
1435 }
1436
1437 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeDefinesendableclass, abc-kind=ArkTS1, category=internal,
1438 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeDefinesendableclass)1439 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeDefinesendableclass)
1440 {
1441 ASSERT_TRUE(CheckMockedStackEmpty());
1442 {
1443 abckit::File f(DEFAULT_PATH);
1444 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1445 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeDefinesendableclass(
1446 abckit::mock::helpers::GetMockCoreFunction(f), abckit::mock::helpers::GetMockLiteralArray(f), DEFAULT_U64,
1447 abckit::mock::helpers::GetMockInstruction(f));
1448 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1449 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeDefinesendableclass"));
1450 }
1451 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1452 ASSERT_TRUE(CheckMockedStackEmpty());
1453 }
1454
1455 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeLdsendableclass, abc-kind=ArkTS1, category=internal,
1456 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeLdsendableclass)1457 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeLdsendableclass)
1458 {
1459 ASSERT_TRUE(CheckMockedStackEmpty());
1460 {
1461 abckit::File f(DEFAULT_PATH);
1462 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1463 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeLdsendableclass(DEFAULT_U64);
1464 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1465 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeLdsendableclass"));
1466 }
1467 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1468 ASSERT_TRUE(CheckMockedStackEmpty());
1469 }
1470
1471 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeLdsendableexternalmodulevar, abc-kind=ArkTS1,
1472 // category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeLdsendableexternalmodulevar)1473 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeLdsendableexternalmodulevar)
1474 {
1475 ASSERT_TRUE(CheckMockedStackEmpty());
1476 {
1477 abckit::File f(DEFAULT_PATH);
1478 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1479 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeLdsendableexternalmodulevar(DEFAULT_U64);
1480 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1481 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeLdsendableexternalmodulevar"));
1482 }
1483 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1484 ASSERT_TRUE(CheckMockedStackEmpty());
1485 }
1486
1487 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeWideldsendableexternalmodulevar, abc-kind=ArkTS1,
1488 // category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeWideldsendableexternalmodulevar)1489 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeWideldsendableexternalmodulevar)
1490 {
1491 ASSERT_TRUE(CheckMockedStackEmpty());
1492 {
1493 abckit::File f(DEFAULT_PATH);
1494 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1495 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeWideldsendableexternalmodulevar(DEFAULT_U64);
1496 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1497 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeWideldsendableexternalmodulevar"));
1498 }
1499 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1500 ASSERT_TRUE(CheckMockedStackEmpty());
1501 }
1502
1503 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeNewsendableenv, abc-kind=ArkTS1, category=internal,
1504 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeNewsendableenv)1505 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeNewsendableenv)
1506 {
1507 ASSERT_TRUE(CheckMockedStackEmpty());
1508 {
1509 abckit::File f(DEFAULT_PATH);
1510 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1511 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeNewsendableenv(DEFAULT_U64);
1512 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1513 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeNewsendableenv"));
1514 }
1515 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1516 ASSERT_TRUE(CheckMockedStackEmpty());
1517 }
1518
1519 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeWidenewsendableenv, abc-kind=ArkTS1, category=internal,
1520 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeWidenewsendableenv)1521 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeWidenewsendableenv)
1522 {
1523 ASSERT_TRUE(CheckMockedStackEmpty());
1524 {
1525 abckit::File f(DEFAULT_PATH);
1526 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1527 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeWidenewsendableenv(DEFAULT_U64);
1528 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1529 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeWidenewsendableenv"));
1530 }
1531 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1532 ASSERT_TRUE(CheckMockedStackEmpty());
1533 }
1534
1535 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeStsendablevar, abc-kind=ArkTS1, category=internal,
1536 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeStsendablevar)1537 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeStsendablevar)
1538 {
1539 ASSERT_TRUE(CheckMockedStackEmpty());
1540 {
1541 abckit::File f(DEFAULT_PATH);
1542 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1543 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeStsendablevar(
1544 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64, DEFAULT_U64);
1545 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1546 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeStsendablevar"));
1547 }
1548 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1549 ASSERT_TRUE(CheckMockedStackEmpty());
1550 }
1551
1552 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeWidestsendablevar, abc-kind=ArkTS1, category=internal,
1553 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeWidestsendablevar)1554 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeWidestsendablevar)
1555 {
1556 ASSERT_TRUE(CheckMockedStackEmpty());
1557 {
1558 abckit::File f(DEFAULT_PATH);
1559 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1560 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeWidestsendablevar(
1561 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64, DEFAULT_U64);
1562 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1563 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeWidestsendablevar"));
1564 }
1565 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1566 ASSERT_TRUE(CheckMockedStackEmpty());
1567 }
1568
1569 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeLdsendablevar, abc-kind=ArkTS1, category=internal,
1570 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeLdsendablevar)1571 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeLdsendablevar)
1572 {
1573 ASSERT_TRUE(CheckMockedStackEmpty());
1574 {
1575 abckit::File f(DEFAULT_PATH);
1576 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1577 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeLdsendablevar(DEFAULT_U64, DEFAULT_U64);
1578 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1579 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeLdsendablevar"));
1580 }
1581 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1582 ASSERT_TRUE(CheckMockedStackEmpty());
1583 }
1584
1585 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeWideldsendablevar, abc-kind=ArkTS1, category=internal,
1586 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeWideldsendablevar)1587 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeWideldsendablevar)
1588 {
1589 ASSERT_TRUE(CheckMockedStackEmpty());
1590 {
1591 abckit::File f(DEFAULT_PATH);
1592 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1593 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeWideldsendablevar(DEFAULT_U64, DEFAULT_U64);
1594 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1595 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeWideldsendablevar"));
1596 }
1597 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1598 ASSERT_TRUE(CheckMockedStackEmpty());
1599 }
1600
1601 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeIstrue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeIstrue)1602 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeIstrue)
1603 {
1604 ASSERT_TRUE(CheckMockedStackEmpty());
1605 {
1606 abckit::File f(DEFAULT_PATH);
1607 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1608 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeIstrue(
1609 abckit::mock::helpers::GetMockInstruction(f));
1610 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1611 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeIstrue"));
1612 }
1613 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1614 ASSERT_TRUE(CheckMockedStackEmpty());
1615 }
1616
1617 // Test: test-kind=mock, api=DynamicIsa::CreateCallruntimeIsfalse, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallruntimeIsfalse)1618 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallruntimeIsfalse)
1619 {
1620 ASSERT_TRUE(CheckMockedStackEmpty());
1621 {
1622 abckit::File f(DEFAULT_PATH);
1623 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1624 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallruntimeIsfalse(
1625 abckit::mock::helpers::GetMockInstruction(f));
1626 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1627 ASSERT_TRUE(CheckMockedApi("IcreateCallruntimeIsfalse"));
1628 }
1629 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1630 ASSERT_TRUE(CheckMockedStackEmpty());
1631 }
1632
1633 // Test: test-kind=mock, api=DynamicIsa::CreateThrow, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrow)1634 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrow)
1635 {
1636 ASSERT_TRUE(CheckMockedStackEmpty());
1637 {
1638 abckit::File f(DEFAULT_PATH);
1639 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1640 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrow(abckit::mock::helpers::GetMockInstruction(f));
1641 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1642 ASSERT_TRUE(CheckMockedApi("IcreateThrow"));
1643 }
1644 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1645 ASSERT_TRUE(CheckMockedStackEmpty());
1646 }
1647
1648 // Test: test-kind=mock, api=DynamicIsa::CreateThrowNotexists, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrowNotexists)1649 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrowNotexists)
1650 {
1651 ASSERT_TRUE(CheckMockedStackEmpty());
1652 {
1653 abckit::File f(DEFAULT_PATH);
1654 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1655 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrowNotexists();
1656 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1657 ASSERT_TRUE(CheckMockedApi("IcreateThrowNotexists"));
1658 }
1659 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1660 ASSERT_TRUE(CheckMockedStackEmpty());
1661 }
1662
1663 // Test: test-kind=mock, api=DynamicIsa::CreateThrowPatternnoncoercible, abc-kind=ArkTS1, category=internal,
1664 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrowPatternnoncoercible)1665 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrowPatternnoncoercible)
1666 {
1667 ASSERT_TRUE(CheckMockedStackEmpty());
1668 {
1669 abckit::File f(DEFAULT_PATH);
1670 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1671 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrowPatternnoncoercible();
1672 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1673 ASSERT_TRUE(CheckMockedApi("IcreateThrowPatternnoncoercible"));
1674 }
1675 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1676 ASSERT_TRUE(CheckMockedStackEmpty());
1677 }
1678
1679 // Test: test-kind=mock, api=DynamicIsa::CreateThrowDeletesuperproperty, abc-kind=ArkTS1, category=internal,
1680 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrowDeletesuperproperty)1681 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrowDeletesuperproperty)
1682 {
1683 ASSERT_TRUE(CheckMockedStackEmpty());
1684 {
1685 abckit::File f(DEFAULT_PATH);
1686 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1687 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrowDeletesuperproperty();
1688 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1689 ASSERT_TRUE(CheckMockedApi("IcreateThrowDeletesuperproperty"));
1690 }
1691 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1692 ASSERT_TRUE(CheckMockedStackEmpty());
1693 }
1694
1695 // Test: test-kind=mock, api=DynamicIsa::CreateThrowConstassignment, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrowConstassignment)1696 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrowConstassignment)
1697 {
1698 ASSERT_TRUE(CheckMockedStackEmpty());
1699 {
1700 abckit::File f(DEFAULT_PATH);
1701 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1702 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrowConstassignment(
1703 abckit::mock::helpers::GetMockInstruction(f));
1704 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1705 ASSERT_TRUE(CheckMockedApi("IcreateThrowConstassignment"));
1706 }
1707 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1708 ASSERT_TRUE(CheckMockedStackEmpty());
1709 }
1710
1711 // Test: test-kind=mock, api=DynamicIsa::CreateThrowIfnotobject, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrowIfnotobject)1712 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrowIfnotobject)
1713 {
1714 ASSERT_TRUE(CheckMockedStackEmpty());
1715 {
1716 abckit::File f(DEFAULT_PATH);
1717 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1718 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrowIfnotobject(
1719 abckit::mock::helpers::GetMockInstruction(f));
1720 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1721 ASSERT_TRUE(CheckMockedApi("IcreateThrowIfnotobject"));
1722 }
1723 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1724 ASSERT_TRUE(CheckMockedStackEmpty());
1725 }
1726
1727 // Test: test-kind=mock, api=DynamicIsa::CreateThrowUndefinedifhole, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrowUndefinedifhole)1728 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrowUndefinedifhole)
1729 {
1730 ASSERT_TRUE(CheckMockedStackEmpty());
1731 {
1732 abckit::File f(DEFAULT_PATH);
1733 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1734 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrowUndefinedifhole(
1735 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
1736 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1737 ASSERT_TRUE(CheckMockedApi("IcreateThrowUndefinedifhole"));
1738 }
1739 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1740 ASSERT_TRUE(CheckMockedStackEmpty());
1741 }
1742
1743 // Test: test-kind=mock, api=DynamicIsa::CreateThrowIfsupernotcorrectcall, abc-kind=ArkTS1, category=internal,
1744 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrowIfsupernotcorrectcall)1745 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrowIfsupernotcorrectcall)
1746 {
1747 ASSERT_TRUE(CheckMockedStackEmpty());
1748 {
1749 abckit::File f(DEFAULT_PATH);
1750 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1751 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrowIfsupernotcorrectcall(
1752 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64);
1753 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1754 ASSERT_TRUE(CheckMockedApi("IcreateThrowIfsupernotcorrectcall"));
1755 }
1756 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1757 ASSERT_TRUE(CheckMockedStackEmpty());
1758 }
1759
1760 // Test: test-kind=mock, api=DynamicIsa::CreateThrowUndefinedifholewithname, abc-kind=ArkTS1, category=internal,
1761 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateThrowUndefinedifholewithname)1762 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateThrowUndefinedifholewithname)
1763 {
1764 ASSERT_TRUE(CheckMockedStackEmpty());
1765 {
1766 abckit::File f(DEFAULT_PATH);
1767 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1768 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateThrowUndefinedifholewithname(
1769 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_CONST_CHAR);
1770 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1771 ASSERT_TRUE(CheckMockedApi("IcreateThrowUndefinedifholewithname"));
1772 ASSERT_TRUE(CheckMockedApi("CreateString"));
1773 }
1774 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1775 ASSERT_TRUE(CheckMockedStackEmpty());
1776 }
1777
1778 // Test: test-kind=mock, api=DynamicIsa::CreateCallarg0, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallarg0)1779 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallarg0)
1780 {
1781 ASSERT_TRUE(CheckMockedStackEmpty());
1782 {
1783 abckit::File f(DEFAULT_PATH);
1784 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1785 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallarg0(abckit::mock::helpers::GetMockInstruction(f));
1786 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1787 ASSERT_TRUE(CheckMockedApi("IcreateCallarg0"));
1788 }
1789 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1790 ASSERT_TRUE(CheckMockedStackEmpty());
1791 }
1792
1793 // Test: test-kind=mock, api=DynamicIsa::CreateCallarg1, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallarg1)1794 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallarg1)
1795 {
1796 ASSERT_TRUE(CheckMockedStackEmpty());
1797 {
1798 abckit::File f(DEFAULT_PATH);
1799 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1800 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallarg1(abckit::mock::helpers::GetMockInstruction(f),
1801 abckit::mock::helpers::GetMockInstruction(f));
1802 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1803 ASSERT_TRUE(CheckMockedApi("IcreateCallarg1"));
1804 }
1805 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1806 ASSERT_TRUE(CheckMockedStackEmpty());
1807 }
1808
1809 // Test: test-kind=mock, api=DynamicIsa::CreateCallargs2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallargs2)1810 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallargs2)
1811 {
1812 ASSERT_TRUE(CheckMockedStackEmpty());
1813 {
1814 abckit::File f(DEFAULT_PATH);
1815 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1816 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallargs2(abckit::mock::helpers::GetMockInstruction(f),
1817 abckit::mock::helpers::GetMockInstruction(f),
1818 abckit::mock::helpers::GetMockInstruction(f));
1819 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1820 ASSERT_TRUE(CheckMockedApi("IcreateCallargs2"));
1821 }
1822 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1823 ASSERT_TRUE(CheckMockedStackEmpty());
1824 }
1825
1826 // Test: test-kind=mock, api=DynamicIsa::CreateCallargs3, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallargs3)1827 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallargs3)
1828 {
1829 ASSERT_TRUE(CheckMockedStackEmpty());
1830 {
1831 abckit::File f(DEFAULT_PATH);
1832 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1833 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallargs3(
1834 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
1835 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
1836 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1837 ASSERT_TRUE(CheckMockedApi("IcreateCallargs3"));
1838 }
1839 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1840 ASSERT_TRUE(CheckMockedStackEmpty());
1841 }
1842
1843 // Test: test-kind=mock, api=DynamicIsa::CreateCallrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallrange)1844 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallrange)
1845 {
1846 ASSERT_TRUE(CheckMockedStackEmpty());
1847 {
1848 abckit::File f(DEFAULT_PATH);
1849 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1850 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallrange(abckit::mock::helpers::GetMockInstruction(f),
1851 abckit::mock::helpers::GetMockInstruction(f));
1852 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1853 ASSERT_TRUE(CheckMockedApi("IcreateCallrange"));
1854 }
1855 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1856 ASSERT_TRUE(CheckMockedStackEmpty());
1857 }
1858
1859 // Test: test-kind=mock, api=DynamicIsa::CreateWideCallrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideCallrange)1860 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideCallrange)
1861 {
1862 ASSERT_TRUE(CheckMockedStackEmpty());
1863 {
1864 abckit::File f(DEFAULT_PATH);
1865 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1866 abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideCallrange(
1867 abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
1868 ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1869 ASSERT_TRUE(CheckMockedApi("IcreateWideCallrange"));
1870 }
1871 ASSERT_TRUE(CheckMockedApi("CloseFile"));
1872 ASSERT_TRUE(CheckMockedStackEmpty());
1873 }
1874
1875 } // namespace libabckit::test
1876