• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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::CreateSupercallspread, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateSupercallspread)28 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateSupercallspread)
29 {
30     ASSERT_TRUE(CheckMockedStackEmpty());
31     {
32         abckit::File f(DEFAULT_PATH);
33         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
34         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateSupercallspread(
35             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
36         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
37         ASSERT_TRUE(CheckMockedApi("IcreateSupercallspread"));
38     }
39     ASSERT_TRUE(CheckMockedApi("CloseFile"));
40     ASSERT_TRUE(CheckMockedStackEmpty());
41 }
42 
43 // Test: test-kind=mock, api=DynamicIsa::CreateApply, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateApply)44 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateApply)
45 {
46     ASSERT_TRUE(CheckMockedStackEmpty());
47     {
48         abckit::File f(DEFAULT_PATH);
49         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
50         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateApply(abckit::mock::helpers::GetMockInstruction(f),
51                                                                     abckit::mock::helpers::GetMockInstruction(f),
52                                                                     abckit::mock::helpers::GetMockInstruction(f));
53         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
54         ASSERT_TRUE(CheckMockedApi("IcreateApply"));
55     }
56     ASSERT_TRUE(CheckMockedApi("CloseFile"));
57     ASSERT_TRUE(CheckMockedStackEmpty());
58 }
59 
60 // Test: test-kind=mock, api=DynamicIsa::CreateCallthis0, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallthis0)61 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallthis0)
62 {
63     ASSERT_TRUE(CheckMockedStackEmpty());
64     {
65         abckit::File f(DEFAULT_PATH);
66         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
67         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallthis0(abckit::mock::helpers::GetMockInstruction(f),
68                                                                         abckit::mock::helpers::GetMockInstruction(f));
69         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
70         ASSERT_TRUE(CheckMockedApi("IcreateCallthis0"));
71     }
72     ASSERT_TRUE(CheckMockedApi("CloseFile"));
73     ASSERT_TRUE(CheckMockedStackEmpty());
74 }
75 
76 // Test: test-kind=mock, api=DynamicIsa::CreateCallthis1, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallthis1)77 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallthis1)
78 {
79     ASSERT_TRUE(CheckMockedStackEmpty());
80     {
81         abckit::File f(DEFAULT_PATH);
82         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
83         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallthis1(abckit::mock::helpers::GetMockInstruction(f),
84                                                                         abckit::mock::helpers::GetMockInstruction(f),
85                                                                         abckit::mock::helpers::GetMockInstruction(f));
86         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
87         ASSERT_TRUE(CheckMockedApi("IcreateCallthis1"));
88     }
89     ASSERT_TRUE(CheckMockedApi("CloseFile"));
90     ASSERT_TRUE(CheckMockedStackEmpty());
91 }
92 
93 // Test: test-kind=mock, api=DynamicIsa::CreateCallthis2, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallthis2)94 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallthis2)
95 {
96     ASSERT_TRUE(CheckMockedStackEmpty());
97     {
98         abckit::File f(DEFAULT_PATH);
99         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
100         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallthis2(
101             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
102             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
103         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
104         ASSERT_TRUE(CheckMockedApi("IcreateCallthis2"));
105     }
106     ASSERT_TRUE(CheckMockedApi("CloseFile"));
107     ASSERT_TRUE(CheckMockedStackEmpty());
108 }
109 
110 // Test: test-kind=mock, api=DynamicIsa::CreateCallthis3, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallthis3)111 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallthis3)
112 {
113     ASSERT_TRUE(CheckMockedStackEmpty());
114     {
115         abckit::File f(DEFAULT_PATH);
116         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
117         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallthis3(
118             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
119             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
120             abckit::mock::helpers::GetMockInstruction(f));
121         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
122         ASSERT_TRUE(CheckMockedApi("IcreateCallthis3"));
123     }
124     ASSERT_TRUE(CheckMockedApi("CloseFile"));
125     ASSERT_TRUE(CheckMockedStackEmpty());
126 }
127 
128 // Test: test-kind=mock, api=DynamicIsa::CreateCallthisrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCallthisrange)129 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCallthisrange)
130 {
131     ASSERT_TRUE(CheckMockedStackEmpty());
132     {
133         abckit::File f(DEFAULT_PATH);
134         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
135         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCallthisrange(
136             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
137         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
138         ASSERT_TRUE(CheckMockedApi("IcreateCallthisrange"));
139     }
140     ASSERT_TRUE(CheckMockedApi("CloseFile"));
141     ASSERT_TRUE(CheckMockedStackEmpty());
142 }
143 
144 // Test: test-kind=mock, api=DynamicIsa::CreateWideCallthisrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideCallthisrange)145 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideCallthisrange)
146 {
147     ASSERT_TRUE(CheckMockedStackEmpty());
148     {
149         abckit::File f(DEFAULT_PATH);
150         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
151         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideCallthisrange(
152             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
153         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
154         ASSERT_TRUE(CheckMockedApi("IcreateWideCallthisrange"));
155     }
156     ASSERT_TRUE(CheckMockedApi("CloseFile"));
157     ASSERT_TRUE(CheckMockedStackEmpty());
158 }
159 
160 // Test: test-kind=mock, api=DynamicIsa::CreateSupercallthisrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateSupercallthisrange)161 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateSupercallthisrange)
162 {
163     ASSERT_TRUE(CheckMockedStackEmpty());
164     {
165         abckit::File f(DEFAULT_PATH);
166         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
167         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateSupercallthisrange(
168             abckit::mock::helpers::GetMockInstruction(f));
169         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
170         ASSERT_TRUE(CheckMockedApi("IcreateSupercallthisrange"));
171     }
172     ASSERT_TRUE(CheckMockedApi("CloseFile"));
173     ASSERT_TRUE(CheckMockedStackEmpty());
174 }
175 
176 // Test: test-kind=mock, api=DynamicIsa::CreateWideSupercallthisrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideSupercallthisrange)177 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideSupercallthisrange)
178 {
179     ASSERT_TRUE(CheckMockedStackEmpty());
180     {
181         abckit::File f(DEFAULT_PATH);
182         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
183         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideSupercallthisrange(
184             abckit::mock::helpers::GetMockInstruction(f));
185         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
186         ASSERT_TRUE(CheckMockedApi("IcreateWideSupercallthisrange"));
187     }
188     ASSERT_TRUE(CheckMockedApi("CloseFile"));
189     ASSERT_TRUE(CheckMockedStackEmpty());
190 }
191 
192 // Test: test-kind=mock, api=DynamicIsa::CreateSupercallarrowrange, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateSupercallarrowrange)193 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateSupercallarrowrange)
194 {
195     ASSERT_TRUE(CheckMockedStackEmpty());
196     {
197         abckit::File f(DEFAULT_PATH);
198         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
199         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateSupercallarrowrange(
200             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
201         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
202         ASSERT_TRUE(CheckMockedApi("IcreateSupercallarrowrange"));
203     }
204     ASSERT_TRUE(CheckMockedApi("CloseFile"));
205     ASSERT_TRUE(CheckMockedStackEmpty());
206 }
207 
208 // Test: test-kind=mock, api=DynamicIsa::CreateWideSupercallarrowrange, abc-kind=ArkTS1, category=internal,
209 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideSupercallarrowrange)210 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideSupercallarrowrange)
211 {
212     ASSERT_TRUE(CheckMockedStackEmpty());
213     {
214         abckit::File f(DEFAULT_PATH);
215         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
216         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideSupercallarrowrange(
217             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
218         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
219         ASSERT_TRUE(CheckMockedApi("IcreateWideSupercallarrowrange"));
220     }
221     ASSERT_TRUE(CheckMockedApi("CloseFile"));
222     ASSERT_TRUE(CheckMockedStackEmpty());
223 }
224 
225 // Test: test-kind=mock, api=DynamicIsa::CreateDefinegettersetterbyvalue, abc-kind=ArkTS1, category=internal,
226 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDefinegettersetterbyvalue)227 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDefinegettersetterbyvalue)
228 {
229     ASSERT_TRUE(CheckMockedStackEmpty());
230     {
231         abckit::File f(DEFAULT_PATH);
232         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
233         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDefinegettersetterbyvalue(
234             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
235             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
236             abckit::mock::helpers::GetMockInstruction(f));
237         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
238         ASSERT_TRUE(CheckMockedApi("IcreateDefinegettersetterbyvalue"));
239     }
240     ASSERT_TRUE(CheckMockedApi("CloseFile"));
241     ASSERT_TRUE(CheckMockedStackEmpty());
242 }
243 
244 // Test: test-kind=mock, api=DynamicIsa::CreateDefinefunc, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDefinefunc)245 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDefinefunc)
246 {
247     ASSERT_TRUE(CheckMockedStackEmpty());
248     {
249         abckit::File f(DEFAULT_PATH);
250         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
251         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDefinefunc(abckit::mock::helpers::GetMockCoreFunction(f),
252                                                                          DEFAULT_U64);
253         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
254         ASSERT_TRUE(CheckMockedApi("IcreateDefinefunc"));
255     }
256     ASSERT_TRUE(CheckMockedApi("CloseFile"));
257     ASSERT_TRUE(CheckMockedStackEmpty());
258 }
259 
260 // Test: test-kind=mock, api=DynamicIsa::CreateDefinemethod, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDefinemethod)261 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDefinemethod)
262 {
263     ASSERT_TRUE(CheckMockedStackEmpty());
264     {
265         abckit::File f(DEFAULT_PATH);
266         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
267         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDefinemethod(
268             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockCoreFunction(f), DEFAULT_U64);
269         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
270         ASSERT_TRUE(CheckMockedApi("IcreateDefinemethod"));
271     }
272     ASSERT_TRUE(CheckMockedApi("CloseFile"));
273     ASSERT_TRUE(CheckMockedStackEmpty());
274 }
275 
276 // Test: test-kind=mock, api=DynamicIsa::CreateDefineclasswithbuffer, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDefineclasswithbuffer)277 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDefineclasswithbuffer)
278 {
279     ASSERT_TRUE(CheckMockedStackEmpty());
280     {
281         abckit::File f(DEFAULT_PATH);
282         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
283         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDefineclasswithbuffer(
284             abckit::mock::helpers::GetMockCoreFunction(f), abckit::mock::helpers::GetMockLiteralArray(f), DEFAULT_U64,
285             abckit::mock::helpers::GetMockInstruction(f));
286         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
287         ASSERT_TRUE(CheckMockedApi("IcreateDefineclasswithbuffer"));
288     }
289     ASSERT_TRUE(CheckMockedApi("CloseFile"));
290     ASSERT_TRUE(CheckMockedStackEmpty());
291 }
292 
293 // Test: test-kind=mock, api=DynamicIsa::CreateResumegenerator, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateResumegenerator)294 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateResumegenerator)
295 {
296     ASSERT_TRUE(CheckMockedStackEmpty());
297     {
298         abckit::File f(DEFAULT_PATH);
299         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
300         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateResumegenerator(
301             abckit::mock::helpers::GetMockInstruction(f));
302         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
303         ASSERT_TRUE(CheckMockedApi("IcreateResumegenerator"));
304     }
305     ASSERT_TRUE(CheckMockedApi("CloseFile"));
306     ASSERT_TRUE(CheckMockedStackEmpty());
307 }
308 
309 // Test: test-kind=mock, api=DynamicIsa::CreateGetresumemode, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGetresumemode)310 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGetresumemode)
311 {
312     ASSERT_TRUE(CheckMockedStackEmpty());
313     {
314         abckit::File f(DEFAULT_PATH);
315         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
316         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGetresumemode(
317             abckit::mock::helpers::GetMockInstruction(f));
318         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
319         ASSERT_TRUE(CheckMockedApi("IcreateGetresumemode"));
320     }
321     ASSERT_TRUE(CheckMockedApi("CloseFile"));
322     ASSERT_TRUE(CheckMockedStackEmpty());
323 }
324 
325 // Test: test-kind=mock, api=DynamicIsa::CreateGettemplateobject, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGettemplateobject)326 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGettemplateobject)
327 {
328     ASSERT_TRUE(CheckMockedStackEmpty());
329     {
330         abckit::File f(DEFAULT_PATH);
331         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
332         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGettemplateobject(
333             abckit::mock::helpers::GetMockInstruction(f));
334         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
335         ASSERT_TRUE(CheckMockedApi("IcreateGettemplateobject"));
336     }
337     ASSERT_TRUE(CheckMockedApi("CloseFile"));
338     ASSERT_TRUE(CheckMockedStackEmpty());
339 }
340 
341 // Test: test-kind=mock, api=DynamicIsa::CreateGetnextpropname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGetnextpropname)342 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGetnextpropname)
343 {
344     ASSERT_TRUE(CheckMockedStackEmpty());
345     {
346         abckit::File f(DEFAULT_PATH);
347         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
348         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGetnextpropname(
349             abckit::mock::helpers::GetMockInstruction(f));
350         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
351         ASSERT_TRUE(CheckMockedApi("IcreateGetnextpropname"));
352     }
353     ASSERT_TRUE(CheckMockedApi("CloseFile"));
354     ASSERT_TRUE(CheckMockedStackEmpty());
355 }
356 
357 // Test: test-kind=mock, api=DynamicIsa::CreateDelobjprop, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDelobjprop)358 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDelobjprop)
359 {
360     ASSERT_TRUE(CheckMockedStackEmpty());
361     {
362         abckit::File f(DEFAULT_PATH);
363         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
364         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDelobjprop(abckit::mock::helpers::GetMockInstruction(f),
365                                                                          abckit::mock::helpers::GetMockInstruction(f));
366         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
367         ASSERT_TRUE(CheckMockedApi("IcreateDelobjprop"));
368     }
369     ASSERT_TRUE(CheckMockedApi("CloseFile"));
370     ASSERT_TRUE(CheckMockedStackEmpty());
371 }
372 
373 // Test: test-kind=mock, api=DynamicIsa::CreateSuspendgenerator, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateSuspendgenerator)374 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateSuspendgenerator)
375 {
376     ASSERT_TRUE(CheckMockedStackEmpty());
377     {
378         abckit::File f(DEFAULT_PATH);
379         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
380         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateSuspendgenerator(
381             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
382         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
383         ASSERT_TRUE(CheckMockedApi("IcreateSuspendgenerator"));
384     }
385     ASSERT_TRUE(CheckMockedApi("CloseFile"));
386     ASSERT_TRUE(CheckMockedStackEmpty());
387 }
388 
389 // Test: test-kind=mock, api=DynamicIsa::CreateAsyncfunctionawaituncaught, abc-kind=ArkTS1, category=internal,
390 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAsyncfunctionawaituncaught)391 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAsyncfunctionawaituncaught)
392 {
393     ASSERT_TRUE(CheckMockedStackEmpty());
394     {
395         abckit::File f(DEFAULT_PATH);
396         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
397         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAsyncfunctionawaituncaught(
398             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
399         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
400         ASSERT_TRUE(CheckMockedApi("IcreateAsyncfunctionawaituncaught"));
401     }
402     ASSERT_TRUE(CheckMockedApi("CloseFile"));
403     ASSERT_TRUE(CheckMockedStackEmpty());
404 }
405 
406 // Test: test-kind=mock, api=DynamicIsa::CreateCopydataproperties, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCopydataproperties)407 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCopydataproperties)
408 {
409     ASSERT_TRUE(CheckMockedStackEmpty());
410     {
411         abckit::File f(DEFAULT_PATH);
412         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
413         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCopydataproperties(
414             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
415         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
416         ASSERT_TRUE(CheckMockedApi("IcreateCopydataproperties"));
417     }
418     ASSERT_TRUE(CheckMockedApi("CloseFile"));
419     ASSERT_TRUE(CheckMockedStackEmpty());
420 }
421 
422 // Test: test-kind=mock, api=DynamicIsa::CreateStarrayspread, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStarrayspread)423 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStarrayspread)
424 {
425     ASSERT_TRUE(CheckMockedStackEmpty());
426     {
427         abckit::File f(DEFAULT_PATH);
428         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
429         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStarrayspread(
430             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
431             abckit::mock::helpers::GetMockInstruction(f));
432         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
433         ASSERT_TRUE(CheckMockedApi("IcreateStarrayspread"));
434     }
435     ASSERT_TRUE(CheckMockedApi("CloseFile"));
436     ASSERT_TRUE(CheckMockedStackEmpty());
437 }
438 
439 // Test: test-kind=mock, api=DynamicIsa::CreateSetobjectwithproto, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateSetobjectwithproto)440 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateSetobjectwithproto)
441 {
442     ASSERT_TRUE(CheckMockedStackEmpty());
443     {
444         abckit::File f(DEFAULT_PATH);
445         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
446         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateSetobjectwithproto(
447             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
448         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
449         ASSERT_TRUE(CheckMockedApi("IcreateSetobjectwithproto"));
450     }
451     ASSERT_TRUE(CheckMockedApi("CloseFile"));
452     ASSERT_TRUE(CheckMockedStackEmpty());
453 }
454 
455 // Test: test-kind=mock, api=DynamicIsa::CreateLdobjbyvalue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdobjbyvalue)456 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdobjbyvalue)
457 {
458     ASSERT_TRUE(CheckMockedStackEmpty());
459     {
460         abckit::File f(DEFAULT_PATH);
461         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
462         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdobjbyvalue(
463             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
464         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
465         ASSERT_TRUE(CheckMockedApi("IcreateLdobjbyvalue"));
466     }
467     ASSERT_TRUE(CheckMockedApi("CloseFile"));
468     ASSERT_TRUE(CheckMockedStackEmpty());
469 }
470 
471 // Test: test-kind=mock, api=DynamicIsa::CreateStobjbyvalue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStobjbyvalue)472 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStobjbyvalue)
473 {
474     ASSERT_TRUE(CheckMockedStackEmpty());
475     {
476         abckit::File f(DEFAULT_PATH);
477         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
478         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStobjbyvalue(
479             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
480             abckit::mock::helpers::GetMockInstruction(f));
481         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
482         ASSERT_TRUE(CheckMockedApi("IcreateStobjbyvalue"));
483     }
484     ASSERT_TRUE(CheckMockedApi("CloseFile"));
485     ASSERT_TRUE(CheckMockedStackEmpty());
486 }
487 
488 // Test: test-kind=mock, api=DynamicIsa::CreateStownbyvalue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStownbyvalue)489 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStownbyvalue)
490 {
491     ASSERT_TRUE(CheckMockedStackEmpty());
492     {
493         abckit::File f(DEFAULT_PATH);
494         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
495         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStownbyvalue(
496             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
497             abckit::mock::helpers::GetMockInstruction(f));
498         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
499         ASSERT_TRUE(CheckMockedApi("IcreateStownbyvalue"));
500     }
501     ASSERT_TRUE(CheckMockedApi("CloseFile"));
502     ASSERT_TRUE(CheckMockedStackEmpty());
503 }
504 
505 // Test: test-kind=mock, api=DynamicIsa::CreateLdsuperbyvalue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdsuperbyvalue)506 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdsuperbyvalue)
507 {
508     ASSERT_TRUE(CheckMockedStackEmpty());
509     {
510         abckit::File f(DEFAULT_PATH);
511         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
512         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdsuperbyvalue(
513             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
514         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
515         ASSERT_TRUE(CheckMockedApi("IcreateLdsuperbyvalue"));
516     }
517     ASSERT_TRUE(CheckMockedApi("CloseFile"));
518     ASSERT_TRUE(CheckMockedStackEmpty());
519 }
520 
521 // Test: test-kind=mock, api=DynamicIsa::CreateStsuperbyvalue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStsuperbyvalue)522 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStsuperbyvalue)
523 {
524     ASSERT_TRUE(CheckMockedStackEmpty());
525     {
526         abckit::File f(DEFAULT_PATH);
527         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
528         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStsuperbyvalue(
529             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
530             abckit::mock::helpers::GetMockInstruction(f));
531         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
532         ASSERT_TRUE(CheckMockedApi("IcreateStsuperbyvalue"));
533     }
534     ASSERT_TRUE(CheckMockedApi("CloseFile"));
535     ASSERT_TRUE(CheckMockedStackEmpty());
536 }
537 
538 // Test: test-kind=mock, api=DynamicIsa::CreateLdobjbyindex, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdobjbyindex)539 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdobjbyindex)
540 {
541     ASSERT_TRUE(CheckMockedStackEmpty());
542     {
543         abckit::File f(DEFAULT_PATH);
544         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
545         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdobjbyindex(abckit::mock::helpers::GetMockInstruction(f),
546                                                                            DEFAULT_U64);
547         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
548         ASSERT_TRUE(CheckMockedApi("IcreateLdobjbyindex"));
549     }
550     ASSERT_TRUE(CheckMockedApi("CloseFile"));
551     ASSERT_TRUE(CheckMockedStackEmpty());
552 }
553 
554 // Test: test-kind=mock, api=DynamicIsa::CreateWideLdobjbyindex, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideLdobjbyindex)555 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideLdobjbyindex)
556 {
557     ASSERT_TRUE(CheckMockedStackEmpty());
558     {
559         abckit::File f(DEFAULT_PATH);
560         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
561         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideLdobjbyindex(
562             abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64);
563         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
564         ASSERT_TRUE(CheckMockedApi("IcreateWideLdobjbyindex"));
565     }
566     ASSERT_TRUE(CheckMockedApi("CloseFile"));
567     ASSERT_TRUE(CheckMockedStackEmpty());
568 }
569 
570 // Test: test-kind=mock, api=DynamicIsa::CreateStobjbyindex, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStobjbyindex)571 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStobjbyindex)
572 {
573     ASSERT_TRUE(CheckMockedStackEmpty());
574     {
575         abckit::File f(DEFAULT_PATH);
576         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
577         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStobjbyindex(
578             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64);
579         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
580         ASSERT_TRUE(CheckMockedApi("IcreateStobjbyindex"));
581     }
582     ASSERT_TRUE(CheckMockedApi("CloseFile"));
583     ASSERT_TRUE(CheckMockedStackEmpty());
584 }
585 
586 // Test: test-kind=mock, api=DynamicIsa::CreateWideStobjbyindex, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideStobjbyindex)587 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideStobjbyindex)
588 {
589     ASSERT_TRUE(CheckMockedStackEmpty());
590     {
591         abckit::File f(DEFAULT_PATH);
592         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
593         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideStobjbyindex(
594             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64);
595         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
596         ASSERT_TRUE(CheckMockedApi("IcreateWideStobjbyindex"));
597     }
598     ASSERT_TRUE(CheckMockedApi("CloseFile"));
599     ASSERT_TRUE(CheckMockedStackEmpty());
600 }
601 
602 // Test: test-kind=mock, api=DynamicIsa::CreateStownbyindex, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStownbyindex)603 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStownbyindex)
604 {
605     ASSERT_TRUE(CheckMockedStackEmpty());
606     {
607         abckit::File f(DEFAULT_PATH);
608         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
609         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStownbyindex(
610             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64);
611         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
612         ASSERT_TRUE(CheckMockedApi("IcreateStownbyindex"));
613     }
614     ASSERT_TRUE(CheckMockedApi("CloseFile"));
615     ASSERT_TRUE(CheckMockedStackEmpty());
616 }
617 
618 // Test: test-kind=mock, api=DynamicIsa::CreateWideStownbyindex, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideStownbyindex)619 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideStownbyindex)
620 {
621     ASSERT_TRUE(CheckMockedStackEmpty());
622     {
623         abckit::File f(DEFAULT_PATH);
624         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
625         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideStownbyindex(
626             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64);
627         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
628         ASSERT_TRUE(CheckMockedApi("IcreateWideStownbyindex"));
629     }
630     ASSERT_TRUE(CheckMockedApi("CloseFile"));
631     ASSERT_TRUE(CheckMockedStackEmpty());
632 }
633 
634 // Test: test-kind=mock, api=DynamicIsa::CreateAsyncfunctionresolve, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAsyncfunctionresolve)635 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAsyncfunctionresolve)
636 {
637     ASSERT_TRUE(CheckMockedStackEmpty());
638     {
639         abckit::File f(DEFAULT_PATH);
640         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
641         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAsyncfunctionresolve(
642             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
643         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
644         ASSERT_TRUE(CheckMockedApi("IcreateAsyncfunctionresolve"));
645     }
646     ASSERT_TRUE(CheckMockedApi("CloseFile"));
647     ASSERT_TRUE(CheckMockedStackEmpty());
648 }
649 
650 // Test: test-kind=mock, api=DynamicIsa::CreateAsyncfunctionreject, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAsyncfunctionreject)651 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAsyncfunctionreject)
652 {
653     ASSERT_TRUE(CheckMockedStackEmpty());
654     {
655         abckit::File f(DEFAULT_PATH);
656         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
657         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAsyncfunctionreject(
658             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
659         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
660         ASSERT_TRUE(CheckMockedApi("IcreateAsyncfunctionreject"));
661     }
662     ASSERT_TRUE(CheckMockedApi("CloseFile"));
663     ASSERT_TRUE(CheckMockedStackEmpty());
664 }
665 
666 // Test: test-kind=mock, api=DynamicIsa::CreateCopyrestargs, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateCopyrestargs)667 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateCopyrestargs)
668 {
669     ASSERT_TRUE(CheckMockedStackEmpty());
670     {
671         abckit::File f(DEFAULT_PATH);
672         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
673         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateCopyrestargs(DEFAULT_U64);
674         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
675         ASSERT_TRUE(CheckMockedApi("IcreateCopyrestargs"));
676     }
677     ASSERT_TRUE(CheckMockedApi("CloseFile"));
678     ASSERT_TRUE(CheckMockedStackEmpty());
679 }
680 
681 // Test: test-kind=mock, api=DynamicIsa::CreateWideCopyrestargs, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideCopyrestargs)682 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideCopyrestargs)
683 {
684     ASSERT_TRUE(CheckMockedStackEmpty());
685     {
686         abckit::File f(DEFAULT_PATH);
687         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
688         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideCopyrestargs(DEFAULT_U64);
689         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
690         ASSERT_TRUE(CheckMockedApi("IcreateWideCopyrestargs"));
691     }
692     ASSERT_TRUE(CheckMockedApi("CloseFile"));
693     ASSERT_TRUE(CheckMockedStackEmpty());
694 }
695 
696 // Test: test-kind=mock, api=DynamicIsa::CreateLdlexvar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdlexvar)697 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdlexvar)
698 {
699     ASSERT_TRUE(CheckMockedStackEmpty());
700     {
701         abckit::File f(DEFAULT_PATH);
702         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
703         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdlexvar(DEFAULT_U64, DEFAULT_U64);
704         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
705         ASSERT_TRUE(CheckMockedApi("IcreateLdlexvar"));
706     }
707     ASSERT_TRUE(CheckMockedApi("CloseFile"));
708     ASSERT_TRUE(CheckMockedStackEmpty());
709 }
710 
711 // Test: test-kind=mock, api=DynamicIsa::CreateWideLdlexvar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideLdlexvar)712 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideLdlexvar)
713 {
714     ASSERT_TRUE(CheckMockedStackEmpty());
715     {
716         abckit::File f(DEFAULT_PATH);
717         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
718         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideLdlexvar(DEFAULT_U64, DEFAULT_U64);
719         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
720         ASSERT_TRUE(CheckMockedApi("IcreateWideLdlexvar"));
721     }
722     ASSERT_TRUE(CheckMockedApi("CloseFile"));
723     ASSERT_TRUE(CheckMockedStackEmpty());
724 }
725 
726 // Test: test-kind=mock, api=DynamicIsa::CreateStlexvar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStlexvar)727 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStlexvar)
728 {
729     ASSERT_TRUE(CheckMockedStackEmpty());
730     {
731         abckit::File f(DEFAULT_PATH);
732         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
733         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStlexvar(abckit::mock::helpers::GetMockInstruction(f),
734                                                                        DEFAULT_U64, DEFAULT_U64);
735         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
736         ASSERT_TRUE(CheckMockedApi("IcreateStlexvar"));
737     }
738     ASSERT_TRUE(CheckMockedApi("CloseFile"));
739     ASSERT_TRUE(CheckMockedStackEmpty());
740 }
741 
742 // Test: test-kind=mock, api=DynamicIsa::CreateWideStlexvar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideStlexvar)743 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideStlexvar)
744 {
745     ASSERT_TRUE(CheckMockedStackEmpty());
746     {
747         abckit::File f(DEFAULT_PATH);
748         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
749         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideStlexvar(abckit::mock::helpers::GetMockInstruction(f),
750                                                                            DEFAULT_U64, DEFAULT_U64);
751         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
752         ASSERT_TRUE(CheckMockedApi("IcreateWideStlexvar"));
753     }
754     ASSERT_TRUE(CheckMockedApi("CloseFile"));
755     ASSERT_TRUE(CheckMockedStackEmpty());
756 }
757 
758 // Test: test-kind=mock, api=DynamicIsa::CreateGetmodulenamespace, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateGetmodulenamespace)759 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateGetmodulenamespace)
760 {
761     ASSERT_TRUE(CheckMockedStackEmpty());
762     {
763         abckit::File f(DEFAULT_PATH);
764         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
765         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateGetmodulenamespace(
766             abckit::mock::helpers::GetMockCoreModule(f));
767         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
768         ASSERT_TRUE(CheckMockedApi("IcreateGetmodulenamespace"));
769     }
770     ASSERT_TRUE(CheckMockedApi("CloseFile"));
771     ASSERT_TRUE(CheckMockedStackEmpty());
772 }
773 
774 // Test: test-kind=mock, api=DynamicIsa::CreateWideGetmodulenamespace, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideGetmodulenamespace)775 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideGetmodulenamespace)
776 {
777     ASSERT_TRUE(CheckMockedStackEmpty());
778     {
779         abckit::File f(DEFAULT_PATH);
780         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
781         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideGetmodulenamespace(
782             abckit::mock::helpers::GetMockCoreModule(f));
783         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
784         ASSERT_TRUE(CheckMockedApi("IcreateWideGetmodulenamespace"));
785     }
786     ASSERT_TRUE(CheckMockedApi("CloseFile"));
787     ASSERT_TRUE(CheckMockedStackEmpty());
788 }
789 
790 // Test: test-kind=mock, api=DynamicIsa::CreateStmodulevar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStmodulevar)791 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStmodulevar)
792 {
793     ASSERT_TRUE(CheckMockedStackEmpty());
794     {
795         abckit::File f(DEFAULT_PATH);
796         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
797         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStmodulevar(
798             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockCoreExportDescriptor(f));
799         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
800         ASSERT_TRUE(CheckMockedApi("IcreateStmodulevar"));
801     }
802     ASSERT_TRUE(CheckMockedApi("CloseFile"));
803     ASSERT_TRUE(CheckMockedStackEmpty());
804 }
805 
806 // Test: test-kind=mock, api=DynamicIsa::CreateWideStmodulevar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideStmodulevar)807 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideStmodulevar)
808 {
809     ASSERT_TRUE(CheckMockedStackEmpty());
810     {
811         abckit::File f(DEFAULT_PATH);
812         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
813         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideStmodulevar(
814             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockCoreExportDescriptor(f));
815         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
816         ASSERT_TRUE(CheckMockedApi("IcreateWideStmodulevar"));
817     }
818     ASSERT_TRUE(CheckMockedApi("CloseFile"));
819     ASSERT_TRUE(CheckMockedStackEmpty());
820 }
821 
822 // Test: test-kind=mock, api=DynamicIsa::CreateTryldglobalbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateTryldglobalbyname)823 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateTryldglobalbyname)
824 {
825     ASSERT_TRUE(CheckMockedStackEmpty());
826     {
827         abckit::File f(DEFAULT_PATH);
828         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
829         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateTryldglobalbyname(DEFAULT_CONST_CHAR);
830         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
831         ASSERT_TRUE(CheckMockedApi("IcreateTryldglobalbyname"));
832         ASSERT_TRUE(CheckMockedApi("CreateString"));
833     }
834     ASSERT_TRUE(CheckMockedApi("CloseFile"));
835     ASSERT_TRUE(CheckMockedStackEmpty());
836 }
837 
838 // Test: test-kind=mock, api=DynamicIsa::CreateTrystglobalbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateTrystglobalbyname)839 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateTrystglobalbyname)
840 {
841     ASSERT_TRUE(CheckMockedStackEmpty());
842     {
843         abckit::File f(DEFAULT_PATH);
844         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
845         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateTrystglobalbyname(
846             abckit::mock::helpers::GetMockInstruction(f), DEFAULT_CONST_CHAR);
847         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
848         ASSERT_TRUE(CheckMockedApi("IcreateTrystglobalbyname"));
849         ASSERT_TRUE(CheckMockedApi("CreateString"));
850     }
851     ASSERT_TRUE(CheckMockedApi("CloseFile"));
852     ASSERT_TRUE(CheckMockedStackEmpty());
853 }
854 
855 // Test: test-kind=mock, api=DynamicIsa::CreateLdglobalvar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdglobalvar)856 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdglobalvar)
857 {
858     ASSERT_TRUE(CheckMockedStackEmpty());
859     {
860         abckit::File f(DEFAULT_PATH);
861         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
862         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdglobalvar(DEFAULT_CONST_CHAR);
863         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
864         ASSERT_TRUE(CheckMockedApi("IcreateLdglobalvar"));
865         ASSERT_TRUE(CheckMockedApi("CreateString"));
866     }
867     ASSERT_TRUE(CheckMockedApi("CloseFile"));
868     ASSERT_TRUE(CheckMockedStackEmpty());
869 }
870 
871 // Test: test-kind=mock, api=DynamicIsa::CreateStglobalvar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStglobalvar)872 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStglobalvar)
873 {
874     ASSERT_TRUE(CheckMockedStackEmpty());
875     {
876         abckit::File f(DEFAULT_PATH);
877         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
878         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStglobalvar(abckit::mock::helpers::GetMockInstruction(f),
879                                                                           DEFAULT_CONST_CHAR);
880         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
881         ASSERT_TRUE(CheckMockedApi("IcreateStglobalvar"));
882         ASSERT_TRUE(CheckMockedApi("CreateString"));
883     }
884     ASSERT_TRUE(CheckMockedApi("CloseFile"));
885     ASSERT_TRUE(CheckMockedStackEmpty());
886 }
887 
888 // Test: test-kind=mock, api=DynamicIsa::CreateLdobjbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdobjbyname)889 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdobjbyname)
890 {
891     ASSERT_TRUE(CheckMockedStackEmpty());
892     {
893         abckit::File f(DEFAULT_PATH);
894         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
895         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdobjbyname(abckit::mock::helpers::GetMockInstruction(f),
896                                                                           DEFAULT_CONST_CHAR);
897         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
898         ASSERT_TRUE(CheckMockedApi("IcreateLdobjbyname"));
899         ASSERT_TRUE(CheckMockedApi("CreateString"));
900     }
901     ASSERT_TRUE(CheckMockedApi("CloseFile"));
902     ASSERT_TRUE(CheckMockedStackEmpty());
903 }
904 
905 // Test: test-kind=mock, api=DynamicIsa::CreateStobjbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStobjbyname)906 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStobjbyname)
907 {
908     ASSERT_TRUE(CheckMockedStackEmpty());
909     {
910         abckit::File f(DEFAULT_PATH);
911         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
912         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStobjbyname(abckit::mock::helpers::GetMockInstruction(f),
913                                                                           DEFAULT_CONST_CHAR,
914                                                                           abckit::mock::helpers::GetMockInstruction(f));
915         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
916         ASSERT_TRUE(CheckMockedApi("IcreateStobjbyname"));
917         ASSERT_TRUE(CheckMockedApi("CreateString"));
918     }
919     ASSERT_TRUE(CheckMockedApi("CloseFile"));
920     ASSERT_TRUE(CheckMockedStackEmpty());
921 }
922 
923 // Test: test-kind=mock, api=DynamicIsa::CreateStownbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStownbyname)924 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStownbyname)
925 {
926     ASSERT_TRUE(CheckMockedStackEmpty());
927     {
928         abckit::File f(DEFAULT_PATH);
929         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
930         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStownbyname(abckit::mock::helpers::GetMockInstruction(f),
931                                                                           DEFAULT_CONST_CHAR,
932                                                                           abckit::mock::helpers::GetMockInstruction(f));
933         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
934         ASSERT_TRUE(CheckMockedApi("IcreateStownbyname"));
935         ASSERT_TRUE(CheckMockedApi("CreateString"));
936     }
937     ASSERT_TRUE(CheckMockedApi("CloseFile"));
938     ASSERT_TRUE(CheckMockedStackEmpty());
939 }
940 
941 // Test: test-kind=mock, api=DynamicIsa::CreateLdsuperbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdsuperbyname)942 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdsuperbyname)
943 {
944     ASSERT_TRUE(CheckMockedStackEmpty());
945     {
946         abckit::File f(DEFAULT_PATH);
947         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
948         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdsuperbyname(
949             abckit::mock::helpers::GetMockInstruction(f), DEFAULT_CONST_CHAR);
950         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
951         ASSERT_TRUE(CheckMockedApi("IcreateLdsuperbyname"));
952         ASSERT_TRUE(CheckMockedApi("CreateString"));
953     }
954     ASSERT_TRUE(CheckMockedApi("CloseFile"));
955     ASSERT_TRUE(CheckMockedStackEmpty());
956 }
957 
958 // Test: test-kind=mock, api=DynamicIsa::CreateStsuperbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStsuperbyname)959 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStsuperbyname)
960 {
961     ASSERT_TRUE(CheckMockedStackEmpty());
962     {
963         abckit::File f(DEFAULT_PATH);
964         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
965         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStsuperbyname(
966             abckit::mock::helpers::GetMockInstruction(f), DEFAULT_CONST_CHAR,
967             abckit::mock::helpers::GetMockInstruction(f));
968         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
969         ASSERT_TRUE(CheckMockedApi("IcreateStsuperbyname"));
970         ASSERT_TRUE(CheckMockedApi("CreateString"));
971     }
972     ASSERT_TRUE(CheckMockedApi("CloseFile"));
973     ASSERT_TRUE(CheckMockedStackEmpty());
974 }
975 
976 // Test: test-kind=mock, api=DynamicIsa::CreateLdlocalmodulevar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdlocalmodulevar)977 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdlocalmodulevar)
978 {
979     ASSERT_TRUE(CheckMockedStackEmpty());
980     {
981         abckit::File f(DEFAULT_PATH);
982         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
983         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdlocalmodulevar(
984             abckit::mock::helpers::GetMockCoreExportDescriptor(f));
985         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
986         ASSERT_TRUE(CheckMockedApi("IcreateLdlocalmodulevar"));
987     }
988     ASSERT_TRUE(CheckMockedApi("CloseFile"));
989     ASSERT_TRUE(CheckMockedStackEmpty());
990 }
991 
992 // Test: test-kind=mock, api=DynamicIsa::CreateWideLdlocalmodulevar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideLdlocalmodulevar)993 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideLdlocalmodulevar)
994 {
995     ASSERT_TRUE(CheckMockedStackEmpty());
996     {
997         abckit::File f(DEFAULT_PATH);
998         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
999         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideLdlocalmodulevar(
1000             abckit::mock::helpers::GetMockCoreExportDescriptor(f));
1001         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1002         ASSERT_TRUE(CheckMockedApi("IcreateWideLdlocalmodulevar"));
1003     }
1004     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1005     ASSERT_TRUE(CheckMockedStackEmpty());
1006 }
1007 
1008 // Test: test-kind=mock, api=DynamicIsa::CreateLdexternalmodulevar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdexternalmodulevar)1009 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdexternalmodulevar)
1010 {
1011     ASSERT_TRUE(CheckMockedStackEmpty());
1012     {
1013         abckit::File f(DEFAULT_PATH);
1014         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1015         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdexternalmodulevar(
1016             abckit::mock::helpers::GetMockCoreImportDescriptor(f));
1017         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1018         ASSERT_TRUE(CheckMockedApi("IcreateLdexternalmodulevar"));
1019     }
1020     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1021     ASSERT_TRUE(CheckMockedStackEmpty());
1022 }
1023 
1024 // Test: test-kind=mock, api=DynamicIsa::CreateWideLdexternalmodulevar, abc-kind=ArkTS1, category=internal,
1025 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideLdexternalmodulevar)1026 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideLdexternalmodulevar)
1027 {
1028     ASSERT_TRUE(CheckMockedStackEmpty());
1029     {
1030         abckit::File f(DEFAULT_PATH);
1031         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1032         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideLdexternalmodulevar(
1033             abckit::mock::helpers::GetMockCoreImportDescriptor(f));
1034         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1035         ASSERT_TRUE(CheckMockedApi("IcreateWideLdexternalmodulevar"));
1036     }
1037     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1038     ASSERT_TRUE(CheckMockedStackEmpty());
1039 }
1040 
1041 // Test: test-kind=mock, api=DynamicIsa::CreateStownbyvaluewithnameset, abc-kind=ArkTS1, category=internal,
1042 // extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStownbyvaluewithnameset)1043 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStownbyvaluewithnameset)
1044 {
1045     ASSERT_TRUE(CheckMockedStackEmpty());
1046     {
1047         abckit::File f(DEFAULT_PATH);
1048         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1049         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStownbyvaluewithnameset(
1050             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f),
1051             abckit::mock::helpers::GetMockInstruction(f));
1052         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1053         ASSERT_TRUE(CheckMockedApi("IcreateStownbyvaluewithnameset"));
1054     }
1055     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1056     ASSERT_TRUE(CheckMockedStackEmpty());
1057 }
1058 
1059 // Test: test-kind=mock, api=DynamicIsa::CreateStownbynamewithnameset, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStownbynamewithnameset)1060 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStownbynamewithnameset)
1061 {
1062     ASSERT_TRUE(CheckMockedStackEmpty());
1063     {
1064         abckit::File f(DEFAULT_PATH);
1065         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1066         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStownbynamewithnameset(
1067             abckit::mock::helpers::GetMockInstruction(f), DEFAULT_CONST_CHAR,
1068             abckit::mock::helpers::GetMockInstruction(f));
1069         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1070         ASSERT_TRUE(CheckMockedApi("IcreateStownbynamewithnameset"));
1071         ASSERT_TRUE(CheckMockedApi("CreateString"));
1072     }
1073     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1074     ASSERT_TRUE(CheckMockedStackEmpty());
1075 }
1076 
1077 // Test: test-kind=mock, api=DynamicIsa::CreateLdbigint, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdbigint)1078 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdbigint)
1079 {
1080     ASSERT_TRUE(CheckMockedStackEmpty());
1081     {
1082         abckit::File f(DEFAULT_PATH);
1083         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1084         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdbigint(DEFAULT_CONST_CHAR);
1085         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1086         ASSERT_TRUE(CheckMockedApi("IcreateLdbigint"));
1087         ASSERT_TRUE(CheckMockedApi("CreateString"));
1088     }
1089     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1090     ASSERT_TRUE(CheckMockedStackEmpty());
1091 }
1092 
1093 // Test: test-kind=mock, api=DynamicIsa::CreateLdthisbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdthisbyname)1094 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdthisbyname)
1095 {
1096     ASSERT_TRUE(CheckMockedStackEmpty());
1097     {
1098         abckit::File f(DEFAULT_PATH);
1099         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1100         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdthisbyname(DEFAULT_CONST_CHAR);
1101         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1102         ASSERT_TRUE(CheckMockedApi("IcreateLdthisbyname"));
1103         ASSERT_TRUE(CheckMockedApi("CreateString"));
1104     }
1105     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1106     ASSERT_TRUE(CheckMockedStackEmpty());
1107 }
1108 
1109 // Test: test-kind=mock, api=DynamicIsa::CreateStthisbyname, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStthisbyname)1110 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStthisbyname)
1111 {
1112     ASSERT_TRUE(CheckMockedStackEmpty());
1113     {
1114         abckit::File f(DEFAULT_PATH);
1115         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1116         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStthisbyname(abckit::mock::helpers::GetMockInstruction(f),
1117                                                                            DEFAULT_CONST_CHAR);
1118         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1119         ASSERT_TRUE(CheckMockedApi("IcreateStthisbyname"));
1120         ASSERT_TRUE(CheckMockedApi("CreateString"));
1121     }
1122     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1123     ASSERT_TRUE(CheckMockedStackEmpty());
1124 }
1125 
1126 // Test: test-kind=mock, api=DynamicIsa::CreateLdthisbyvalue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateLdthisbyvalue)1127 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateLdthisbyvalue)
1128 {
1129     ASSERT_TRUE(CheckMockedStackEmpty());
1130     {
1131         abckit::File f(DEFAULT_PATH);
1132         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1133         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateLdthisbyvalue(
1134             abckit::mock::helpers::GetMockInstruction(f));
1135         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1136         ASSERT_TRUE(CheckMockedApi("IcreateLdthisbyvalue"));
1137     }
1138     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1139     ASSERT_TRUE(CheckMockedStackEmpty());
1140 }
1141 
1142 // Test: test-kind=mock, api=DynamicIsa::CreateStthisbyvalue, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateStthisbyvalue)1143 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateStthisbyvalue)
1144 {
1145     ASSERT_TRUE(CheckMockedStackEmpty());
1146     {
1147         abckit::File f(DEFAULT_PATH);
1148         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1149         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateStthisbyvalue(
1150             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
1151         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1152         ASSERT_TRUE(CheckMockedApi("IcreateStthisbyvalue"));
1153     }
1154     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1155     ASSERT_TRUE(CheckMockedStackEmpty());
1156 }
1157 
1158 // Test: test-kind=mock, api=DynamicIsa::CreateWideLdpatchvar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideLdpatchvar)1159 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideLdpatchvar)
1160 {
1161     ASSERT_TRUE(CheckMockedStackEmpty());
1162     {
1163         abckit::File f(DEFAULT_PATH);
1164         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1165         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideLdpatchvar(DEFAULT_U64);
1166         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1167         ASSERT_TRUE(CheckMockedApi("IcreateWideLdpatchvar"));
1168     }
1169     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1170     ASSERT_TRUE(CheckMockedStackEmpty());
1171 }
1172 
1173 // Test: test-kind=mock, api=DynamicIsa::CreateWideStpatchvar, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateWideStpatchvar)1174 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateWideStpatchvar)
1175 {
1176     ASSERT_TRUE(CheckMockedStackEmpty());
1177     {
1178         abckit::File f(DEFAULT_PATH);
1179         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1180         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateWideStpatchvar(
1181             abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64);
1182         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1183         ASSERT_TRUE(CheckMockedApi("IcreateWideStpatchvar"));
1184     }
1185     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1186     ASSERT_TRUE(CheckMockedStackEmpty());
1187 }
1188 
1189 // Test: test-kind=mock, api=DynamicIsa::CreateDynamicimport, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateDynamicimport)1190 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateDynamicimport)
1191 {
1192     ASSERT_TRUE(CheckMockedStackEmpty());
1193     {
1194         abckit::File f(DEFAULT_PATH);
1195         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1196         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateDynamicimport(
1197             abckit::mock::helpers::GetMockInstruction(f));
1198         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1199         ASSERT_TRUE(CheckMockedApi("IcreateDynamicimport"));
1200     }
1201     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1202     ASSERT_TRUE(CheckMockedStackEmpty());
1203 }
1204 
1205 // Test: test-kind=mock, api=DynamicIsa::CreateAsyncgeneratorreject, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateAsyncgeneratorreject)1206 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateAsyncgeneratorreject)
1207 {
1208     ASSERT_TRUE(CheckMockedStackEmpty());
1209     {
1210         abckit::File f(DEFAULT_PATH);
1211         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1212         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateAsyncgeneratorreject(
1213             abckit::mock::helpers::GetMockInstruction(f), abckit::mock::helpers::GetMockInstruction(f));
1214         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1215         ASSERT_TRUE(CheckMockedApi("IcreateAsyncgeneratorreject"));
1216     }
1217     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1218     ASSERT_TRUE(CheckMockedStackEmpty());
1219 }
1220 
1221 // Test: test-kind=mock, api=DynamicIsa::CreateSetgeneratorstate, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateSetgeneratorstate)1222 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateSetgeneratorstate)
1223 {
1224     ASSERT_TRUE(CheckMockedStackEmpty());
1225     {
1226         abckit::File f(DEFAULT_PATH);
1227         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1228         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateSetgeneratorstate(
1229             abckit::mock::helpers::GetMockInstruction(f), DEFAULT_U64);
1230         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1231         ASSERT_TRUE(CheckMockedApi("IcreateSetgeneratorstate"));
1232     }
1233     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1234     ASSERT_TRUE(CheckMockedStackEmpty());
1235 }
1236 
1237 // Test: test-kind=mock, api=DynamicIsa::CreateReturn, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateReturn)1238 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateReturn)
1239 {
1240     ASSERT_TRUE(CheckMockedStackEmpty());
1241     {
1242         abckit::File f(DEFAULT_PATH);
1243         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1244         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateReturn(abckit::mock::helpers::GetMockInstruction(f));
1245         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1246         ASSERT_TRUE(CheckMockedApi("IcreateReturn"));
1247     }
1248     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1249     ASSERT_TRUE(CheckMockedStackEmpty());
1250 }
1251 
1252 // Test: test-kind=mock, api=DynamicIsa::CreateReturnundefined, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateReturnundefined)1253 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateReturnundefined)
1254 {
1255     ASSERT_TRUE(CheckMockedStackEmpty());
1256     {
1257         abckit::File f(DEFAULT_PATH);
1258         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1259         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateReturnundefined();
1260         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1261         ASSERT_TRUE(CheckMockedApi("IcreateReturnundefined"));
1262     }
1263     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1264     ASSERT_TRUE(CheckMockedStackEmpty());
1265 }
1266 
1267 // Test: test-kind=mock, api=DynamicIsa::CreateIf, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestDynIsa,DynamicIsa_CreateIf)1268 TEST_F(LibAbcKitCppMockTestDynIsa, DynamicIsa_CreateIf)
1269 {
1270     ASSERT_TRUE(CheckMockedStackEmpty());
1271     {
1272         abckit::File f(DEFAULT_PATH);
1273         ASSERT_TRUE(CheckMockedApi("OpenAbc"));
1274         abckit::mock::helpers::GetMockGraph(f).DynIsa().CreateIf(abckit::mock::helpers::GetMockInstruction(f),
1275                                                                  DEFAULT_ENUM_ISA_DYNAMIC_CONDITION_TYPE);
1276         ASSERT_TRUE(CheckMockedApi("DestroyGraph"));
1277         ASSERT_TRUE(CheckMockedApi("IcreateIf"));
1278     }
1279     ASSERT_TRUE(CheckMockedApi("CloseFile"));
1280     ASSERT_TRUE(CheckMockedStackEmpty());
1281 }
1282 
1283 }  // namespace libabckit::test
1284