• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /**
2  * Copyright (c) 2024-2025 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 "libabckit/include/c/abckit.h"
17 #include "libabckit/include/c/isa/isa_dynamic.h"
18 #include "libabckit/include/c/statuses.h"
19 #include "libabckit/include/c/metadata_core.h"
20 #include "libabckit/include/c/ir_core.h"
21 #include "libabckit/include/c/isa/isa_static.h"
22 
23 #include "helpers/helpers.h"
24 #include "helpers/helpers_runtime.h"
25 
26 #include <gtest/gtest.h>
27 #include <cstddef>
28 #include <cstdint>
29 
30 // NOLINTBEGIN(readability-magic-numbers)
31 
32 namespace libabckit::test {
33 
34 namespace {
35 auto g_impl = AbckitGetApiImpl(ABCKIT_VERSION_RELEASE_1_0_0);
36 auto g_implI = AbckitGetInspectApiImpl(ABCKIT_VERSION_RELEASE_1_0_0);
37 auto g_implM = AbckitGetModifyApiImpl(ABCKIT_VERSION_RELEASE_1_0_0);
38 auto g_implG = AbckitGetGraphApiImpl(ABCKIT_VERSION_RELEASE_1_0_0);
39 auto g_dynG = AbckitGetIsaApiDynamicImpl(ABCKIT_VERSION_RELEASE_1_0_0);
40 }  // namespace
41 
42 static constexpr auto CREATE_EMPTY_INPUT_PATH =
43     ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/create_empty_dynamic.abc";
44 
45 class LibAbcKitBasicBlocksDynamicTest : public ::testing::Test {};
46 
47 // Test: test-kind=api, api=GraphApiImpl::bbCreateEmpty, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBcreateEmptyBlock_1)48 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBcreateEmptyBlock_1)
49 {
50     helpers::TransformMethod(
51         CREATE_EMPTY_INPUT_PATH, ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/create_empty_dynamic_modified.abc",
52         "test",
53         [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
54             auto *start = g_implG->gGetStartBasicBlock(graph);
55             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
56             auto *main = helpers::BBgetSuccBlocks(start)[0];
57             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
58             auto *bb = g_implG->bbCreateEmpty(graph);
59             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
60 
61             g_implG->bbDisconnectSuccBlock(start, 0);
62             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
63             g_implG->bbInsertSuccBlock(start, bb, 0);
64             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
65             g_implG->bbInsertSuccBlock(bb, main, 0);
66             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
67 
68             std::vector<helpers::BBSchema<AbckitIsaApiDynamicOpcode>> bbSchemas(
69                 {{{},
70                   {1},
71                   {{4, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
72                    {5, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
73                    {6, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}}}},
74                  {{0}, {2}, {}},
75                  {{1},
76                   {3},
77                   {
78                       {2, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURNUNDEFINED, {}},
79                   }},
80                  {{2}, {}, {}}});
81             helpers::VerifyGraph(graph, bbSchemas);
82 
83             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
84         },
85         []([[maybe_unused]] AbckitGraph *graph) {});
86 }
87 
88 // Test: test-kind=api, api=GraphApiImpl::bbDisconnectSuccBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBdisconnectSuccBlock)89 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBdisconnectSuccBlock)
90 {
91     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
92         auto *start = g_implG->gGetStartBasicBlock(graph);
93         auto *next = helpers::BBgetSuccBlocks(start)[0];
94         g_implG->bbDisconnectSuccBlock(start, 0);
95         ASSERT_TRUE(helpers::BBgetSuccBlocks(start).empty());
96         ASSERT_TRUE(helpers::BBgetPredBlocks(next).empty());
97         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
98         g_implG->bbAppendSuccBlock(start, next);
99         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
100         std::vector<helpers::BBSchema<AbckitIsaApiDynamicOpcode>> bbSchemas(
101             {{{},
102               {1},
103               {{4, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
104                {5, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
105                {6, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}}}},
106              {{0},
107               {2},
108               {
109                   {2, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURNUNDEFINED, {}},
110               }},
111              {{1}, {}, {}}});
112         // CC-OFFNXT(G.FMT.02)
113         helpers::VerifyGraph(graph, bbSchemas);
114     };
115     helpers::InspectMethod(CREATE_EMPTY_INPUT_PATH, "test", cb);
116 }
117 
118 // Test: test-kind=api, api=GraphApiImpl::bbGetGraph, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetGraph_1)119 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetGraph_1)
120 {
121     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
122         auto *start = g_implG->gGetStartBasicBlock(graph);
123         auto *bb = g_implG->bbCreateEmpty(graph);
124         auto *end = g_implG->gGetEndBasicBlock(graph);
125 
126         g_implG->bbAppendSuccBlock(start, bb);
127         g_implG->bbAppendSuccBlock(bb, end);
128         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
129         std::vector<helpers::BBSchema<AbckitIsaApiDynamicOpcode>> bbSchemas(
130             {{{},
131               {2, 1},
132               {{4, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
133                {5, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
134                {6, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}}}},
135              {{0}, {3}, {}},
136              {{0},
137               {3},
138               {
139                   {2, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURNUNDEFINED, {}},
140               }},
141              {{2, 1}, {}, {}}});
142         helpers::VerifyGraph(graph, bbSchemas);
143         ASSERT_EQ(graph, graph);
144     };
145     helpers::InspectMethod(CREATE_EMPTY_INPUT_PATH, "test", cb);
146 }
147 
148 // Test: test-kind=api, api=GraphApiImpl::bbGetFirstInst, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetFirstInst_2)149 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetFirstInst_2)
150 {
151     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
152         auto *start = g_implG->gGetStartBasicBlock(graph);
153         auto *bb = helpers::BBgetSuccBlocks(start)[0];
154         auto *inst = g_implG->bbGetFirstInst(bb);
155         ASSERT_EQ(g_dynG->iGetOpcode(inst), ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURNUNDEFINED);
156     };
157     helpers::InspectMethod(CREATE_EMPTY_INPUT_PATH, "test", cb);
158 }
159 
160 // Test: test-kind=api, api=GraphApiImpl::bbGetLastInst, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetLastInst_1)161 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetLastInst_1)
162 {
163     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
164         auto *start = g_implG->gGetStartBasicBlock(graph);
165         auto *bb = helpers::BBgetSuccBlocks(start)[0];
166         auto *inst = g_implG->bbGetLastInst(bb);
167         (void)inst;
168         // CC-OFFNXT(G.FMT.02)
169         ASSERT_EQ(g_dynG->iGetOpcode(inst), ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURNUNDEFINED);
170     };
171     helpers::InspectMethod(CREATE_EMPTY_INPUT_PATH, "test", cb);
172 }
173 
174 // Test: test-kind=api, api=GraphApiImpl::bbGetTrueBranch, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetTrueBranch_1)175 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetTrueBranch_1)
176 {
177     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
178         auto *start = g_implG->gGetStartBasicBlock(graph);
179         auto *cmpB = helpers::BBgetSuccBlocks(start)[0];
180         auto *trueB = g_implG->bbGetTrueBranch(cmpB);
181         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
182         auto *inst = g_implG->bbGetFirstInst(trueB);
183 
184         ASSERT_NE(inst, nullptr);
185         ASSERT_EQ(g_dynG->iGetOpcode(inst), ABCKIT_ISA_API_DYNAMIC_OPCODE_NEG);
186 
187         std::vector<helpers::BBSchema<AbckitIsaApiDynamicOpcode>> bbSchemas(
188             {{{},
189               {1},
190               {
191                   {12, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
192                   {13, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
193                   {14, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
194                   {3, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
195                   {4, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}},
196                   {5, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}},
197                   {8, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}},
198               }},
199              {{0},
200               {3, 2},
201               {
202                   {6, ABCKIT_ISA_API_DYNAMIC_OPCODE_GREATER, {5, 3}},
203                   {7, ABCKIT_ISA_API_DYNAMIC_OPCODE_IF, {6, 8}},
204               }},
205              {{1},
206               {4},
207               {
208                   {9, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURN, {4}},
209               }},
210              {{1},
211               {4},
212               {
213                   {10, ABCKIT_ISA_API_DYNAMIC_OPCODE_NEG, {4}},
214                   {11, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURN, {10}},
215               }},
216              {{2, 3}, {}, {}}});
217         helpers::VerifyGraph(graph, bbSchemas);
218     };
219     helpers::InspectMethod(CREATE_EMPTY_INPUT_PATH, "test2", cb);
220 }
221 
222 // Test: test-kind=api, api=GraphApiImpl::bbGetFalseBranch, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetFalseBranch_1)223 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetFalseBranch_1)
224 {
225     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
226         auto *start = g_implG->gGetStartBasicBlock(graph);
227         auto *cmpB = helpers::BBgetSuccBlocks(start)[0];
228         auto *trueB = g_implG->bbGetFalseBranch(cmpB);
229         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
230         auto *inst = g_implG->bbGetFirstInst(trueB);
231 
232         ASSERT_NE(inst, nullptr);
233         ASSERT_EQ(g_dynG->iGetOpcode(inst), ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURN);
234 
235         std::vector<helpers::BBSchema<AbckitIsaApiDynamicOpcode>> bbSchemas(
236             {{{},
237               {1},
238               {
239                   {12, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
240                   {13, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
241                   {14, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
242                   {3, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
243                   {4, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}},
244                   {5, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}},
245                   {8, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}},
246               }},
247              {{0},
248               {3, 2},
249               {
250                   {6, ABCKIT_ISA_API_DYNAMIC_OPCODE_GREATER, {5, 3}},
251                   {7, ABCKIT_ISA_API_DYNAMIC_OPCODE_IF, {6, 8}},
252               }},
253              {{1},
254               {4},
255               {
256                   {9, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURN, {4}},
257               }},
258              {{1},
259               {4},
260               {
261                   {10, ABCKIT_ISA_API_DYNAMIC_OPCODE_NEG, {4}},
262                   {11, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURN, {10}},
263               }},
264              {{2, 3}, {}, {}}});
265         helpers::VerifyGraph(graph, bbSchemas);
266     };
267     helpers::InspectMethod(CREATE_EMPTY_INPUT_PATH, "test2", cb);
268 }
269 
270 // Test: test-kind=api, api=GraphApiImpl::bbAddInstFront, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBaddInstFront_4)271 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBaddInstFront_4)
272 {
273     helpers::TransformMethod(
274         CREATE_EMPTY_INPUT_PATH, ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/create_empty_dynamic_instfront.abc",
275         "test",
276         [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
277             auto *start = g_implG->gGetStartBasicBlock(graph);
278             auto *bb = helpers::BBgetSuccBlocks(start)[0];
279             auto *inst = helpers::FindFirstInst(graph, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT);
280             auto *newInst = g_implG->gFindOrCreateConstantI64(graph, 1U);
281             auto *negInst = g_dynG->iCreateNeg(graph, newInst);
282             g_implG->bbAddInstFront(bb, negInst);
283             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
284             std::vector<helpers::BBSchema<AbckitIsaApiDynamicOpcode>> bbSchemas(
285                 {{{},
286                   {1},
287                   {{7, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
288                    {8, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
289                    {9, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
290                    {3, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}}}},
291                  {{0},
292                   {2},
293                   {
294                       {4, ABCKIT_ISA_API_DYNAMIC_OPCODE_NEG, {3}},
295                       {5, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURNUNDEFINED, {}},
296                   }},
297                  {{1}, {}, {}}});
298             helpers::VerifyGraph(graph, bbSchemas);
299 
300             ASSERT_EQ(inst, g_implG->iGetNext(newInst));
301         },
302         []([[maybe_unused]] AbckitGraph *graph) {});
303 }
304 
305 // Test: test-kind=api, api=GraphApiImpl::bbAddInstBack, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBaddInstBack_2)306 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBaddInstBack_2)
307 {
308     helpers::TransformMethod(
309         CREATE_EMPTY_INPUT_PATH, ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/create_empty_dynamic_instback.abc",
310         "test",
311         [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
312             auto *start = g_implG->gGetStartBasicBlock(graph);
313             auto *bb = helpers::BBgetSuccBlocks(start)[0];
314             auto *inst = helpers::FindFirstInst(graph, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT);
315             auto *newInst = g_implG->gFindOrCreateConstantI64(graph, 1U);
316             auto *negInst = g_dynG->iCreateNeg(graph, newInst);
317 
318             g_implG->bbDisconnectSuccBlock(start, 0);
319             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
320             auto *empty = g_implG->bbCreateEmpty(graph);
321             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
322             g_implG->bbAppendSuccBlock(start, empty);
323             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
324             g_implG->bbAppendSuccBlock(empty, bb);
325             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
326             g_implG->bbAddInstBack(empty, negInst);
327             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
328             std::vector<helpers::BBSchema<AbckitIsaApiDynamicOpcode>> bbSchemas(
329                 {{{},
330                   {1},
331                   {{6, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
332                    {7, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
333                    {8, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
334                    {3, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}}}},
335                  {{0},
336                   {2},
337                   {
338                       {4, ABCKIT_ISA_API_DYNAMIC_OPCODE_NEG, {3}},
339                   }},
340                  {{1},
341                   {3},
342                   {
343                       {2, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURNUNDEFINED, {}},
344                   }},
345                  {{2}, {}, {}}});
346             helpers::VerifyGraph(graph, bbSchemas);
347 
348             ASSERT_EQ(inst, g_implG->iGetNext(newInst));
349         },
350         []([[maybe_unused]] AbckitGraph *graph) {});
351 }
352 
353 // Test: test-kind=api, api=GraphApiImpl::bbAddInstBack, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBaddInstBack_4)354 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBaddInstBack_4)
355 {
356     helpers::TransformMethod(
357         CREATE_EMPTY_INPUT_PATH, ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/create_empty_dynamic_instback.abc",
358         "test",
359         [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
360             auto *start = g_implG->gGetStartBasicBlock(graph);
361             auto *newIns = g_implG->gFindOrCreateConstantI64(graph, 1);
362 
363             ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
364             std::vector<helpers::BBSchema<AbckitIsaApiDynamicOpcode>> bbSchemas(
365                 {{{},
366                   {1},
367                   {{4, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
368                    {5, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
369                    {6, ABCKIT_ISA_API_DYNAMIC_OPCODE_PARAMETER, {}},
370                    {3, ABCKIT_ISA_API_DYNAMIC_OPCODE_CONSTANT, {}}}},
371                  {{0},
372                   {2},
373                   {
374                       {1, ABCKIT_ISA_API_DYNAMIC_OPCODE_RETURNUNDEFINED, {}},
375                   }},
376                  {{1}, {}, {}}});
377             helpers::VerifyGraph(graph, bbSchemas);
378 
379             ASSERT_EQ(newIns, g_implG->bbGetLastInst(start));
380         },
381         []([[maybe_unused]] AbckitGraph *graph) {});
382 }
383 
384 // Test: test-kind=api, api=GraphApiImpl::bbVisitSuccBlocks, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBvisitSuccBlocks_1)385 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBvisitSuccBlocks_1)
386 {
387     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
388         auto *start = g_implG->gGetStartBasicBlock(graph);
389         auto *bb = helpers::BBgetSuccBlocks(start)[0];
390 
391         uint32_t counter = 0;
392         g_implG->bbVisitSuccBlocks(bb, &counter, [](AbckitBasicBlock *, void *data) {
393             (*(reinterpret_cast<uint32_t *>(data)))++;
394             return true;
395         });
396         // CC-OFFNXT(G.FMT.02)
397         ASSERT_EQ(counter, 1);
398         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
399     };
400     helpers::InspectMethod(CREATE_EMPTY_INPUT_PATH, "test", cb);
401 }
402 
403 // Test: test-kind=api, api=GraphApiImpl::bbVisitPredBlocks, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBvisitPredBlocks_1)404 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBvisitPredBlocks_1)
405 {
406     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
407         auto *start = g_implG->gGetStartBasicBlock(graph);
408         auto *bb = helpers::BBgetSuccBlocks(start)[0];
409 
410         uint32_t counter = 0;
411         g_implG->bbVisitPredBlocks(bb, &counter, [](AbckitBasicBlock *, void *data) {
412             (*(reinterpret_cast<uint32_t *>(data)))++;
413             return true;
414         });
415 
416         ASSERT_EQ(counter, 1);
417         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
418     };
419     helpers::InspectMethod(CREATE_EMPTY_INPUT_PATH, "test", cb);
420 }
421 
422 // Test: test-kind=api, api=GraphApiImpl::bbVisitDominatedBlocks, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBvisitDominatedBlocks_1)423 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBvisitDominatedBlocks_1)
424 {
425     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
426     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
427     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
428         auto *start = g_implG->gGetStartBasicBlock(graph);
429         auto *bb = helpers::BBgetSuccBlocks(start)[0];
430 
431         uint32_t counter = 0;
432         g_implG->bbVisitDominatedBlocks(bb, &counter, [](AbckitBasicBlock *, void *data) {
433             (*(reinterpret_cast<uint32_t *>(data)))++;
434             return true;
435         });
436 
437         ASSERT_EQ(counter, 1);
438         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
439     });
440     g_impl->closeFile(file);
441 }
442 
443 // Test: test-kind=api, api=GraphApiImpl::bbGetSuccBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetSuccBlock_1)444 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetSuccBlock_1)
445 {
446     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
447     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
448     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
449         auto *start = g_implG->gGetStartBasicBlock(graph);
450         auto *bb = g_implG->bbGetSuccBlock(start, 0);
451 
452         ASSERT_EQ(bb, helpers::BBgetSuccBlocks(start)[0]);
453         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
454     });
455     g_impl->closeFile(file);
456 }
457 
458 // Test: test-kind=api, api=GraphApiImpl::bbIsStart, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisStart_1)459 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisStart_1)
460 {
461     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
462     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
463     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
464         auto *start = g_implG->gGetStartBasicBlock(graph);
465 
466         ASSERT_TRUE(g_implG->bbIsStart(start));
467         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
468     });
469     g_impl->closeFile(file);
470 }
471 
472 // Test: test-kind=api, api=GraphApiImpl::bbIsEnd, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisEnd_1)473 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisEnd_1)
474 {
475     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
476     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
477     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
478         auto *end = g_implG->gGetEndBasicBlock(graph);
479 
480         ASSERT_TRUE(g_implG->bbIsEnd(end));
481         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
482     });
483     g_impl->closeFile(file);
484 }
485 
486 // Test: test-kind=api, api=GraphApiImpl::bbGetImmediateDominator, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetImmediateDominator_1)487 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetImmediateDominator_1)
488 {
489     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
490     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
491     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
492         auto *start = g_implG->gGetStartBasicBlock(graph);
493         auto *bb = helpers::BBgetSuccBlocks(start)[0];
494         g_implG->bbGetImmediateDominator(bb);
495         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
496     });
497     g_impl->closeFile(file);
498 }
499 
500 // Test: test-kind=api, api=GraphApiImpl::bbGetImmediateDominator, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetImmediateDominator_2)501 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetImmediateDominator_2)
502 {
503     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
504     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
505     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
506         auto *start = g_implG->gGetStartBasicBlock(graph);
507         auto bb = g_implG->bbGetImmediateDominator(start);
508         ASSERT_EQ(bb, nullptr);
509     });
510     g_impl->closeFile(file);
511 }
512 
513 // Test: test-kind=api, api=GraphApiImpl::bbGetSuccBlockCount, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetSuccBlockCount_1)514 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetSuccBlockCount_1)
515 {
516     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
517     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
518     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
519         auto *start = g_implG->gGetStartBasicBlock(graph);
520 
521         ASSERT_EQ(g_implG->bbGetSuccBlockCount(start), 1);
522         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
523     });
524     g_impl->closeFile(file);
525 }
526 
527 // Test: test-kind=api, api=GraphApiImpl::bbGetPredBlockCount, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetPredBlockCount_1)528 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetPredBlockCount_1)
529 {
530     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
531     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
532     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
533         auto *start = g_implG->gGetStartBasicBlock(graph);
534         auto *bb = helpers::BBgetSuccBlocks(start)[0];
535 
536         ASSERT_EQ(g_implG->bbGetPredBlockCount(bb), 1);
537         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
538     });
539     g_impl->closeFile(file);
540 }
541 
542 // Test: test-kind=api, api=GraphApiImpl::bbDump, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBdump_1)543 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBdump_1)
544 {
545     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
546     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
547     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
548         auto *start = g_implG->gGetStartBasicBlock(graph);
549         LIBABCKIT_LOG_DUMP(g_implG->bbDump(start, 0), DEBUG);
550         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
551     });
552     g_impl->closeFile(file);
553 }
554 
555 // Test: test-kind=api, api=GraphApiImpl::bbGetNumberOfInstructions, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetNumberOfInstructions_1)556 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetNumberOfInstructions_1)
557 {
558     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
559     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
560     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
561         auto *start = g_implG->gGetStartBasicBlock(graph);
562         auto *bb = helpers::BBgetSuccBlocks(start)[0];
563         ASSERT_EQ(g_implG->bbGetNumberOfInstructions(bb), 1U);
564         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
565     });
566     g_impl->closeFile(file);
567 }
568 
569 // Test: test-kind=api, api=GraphApiImpl::gGetBasicBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetBasicBlock_1)570 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetBasicBlock_1)
571 {
572     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
573     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
574     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
575         auto *bb = g_implG->gGetBasicBlock(graph, 1);
576         ASSERT_EQ(bb, g_implG->gGetStartBasicBlock(graph));
577         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
578     });
579     g_impl->closeFile(file);
580 }
581 
582 // Test: test-kind=api, api=GraphApiImpl::gGetBasicBlock, abc-kind=ArkTS1, category=negative
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetBasicBlockBigId)583 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetBasicBlockBigId)
584 {
585     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
586     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
587     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
588         auto bbVectorSize = g_implG->gGetNumberOfBasicBlocks(graph);
589         auto *bb = g_implG->gGetBasicBlock(graph, bbVectorSize + 1);
590         ASSERT_EQ(bb, nullptr);
591         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_BAD_ARGUMENT);
592     });
593     g_impl->closeFile(file);
594 }
595 
596 // Test: test-kind=api, api=GraphApiImpl::gGetParameter, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetParameter_1)597 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetParameter_1)
598 {
599     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
600     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
601     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
602         auto *start = g_implG->gGetStartBasicBlock(graph);
603         auto *inst = g_implG->bbGetFirstInst(start);
604         ASSERT_EQ(inst, g_implG->gGetParameter(graph, 0));
605         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
606     });
607     g_impl->closeFile(file);
608 }
609 
610 // Test: test-kind=api, api=GraphApiImpl::gGetParameter, abc-kind=ArkTS1, category=negative
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetParameterBigId)611 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetParameterBigId)
612 {
613     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
614     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
615     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
616         auto size = g_implG->gGetNumberOfParameters(graph);
617         auto *inst = g_implG->gGetParameter(graph, size + 1);
618         ASSERT_EQ(inst, nullptr);
619         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_BAD_ARGUMENT);
620     });
621     g_impl->closeFile(file);
622 }
623 
624 // Test: test-kind=api, api=GraphApiImpl::gGetNumberOfParameters, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetNumberOfParameters)625 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetNumberOfParameters)
626 {
627     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
628     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
629     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
630         uint32_t num = g_implG->gGetNumberOfParameters(graph);
631         ASSERT_EQ(num, 4U);
632         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
633     });
634     g_impl->closeFile(file);
635 }
636 
637 // Test: test-kind=api, api=GraphApiImpl::gGetNumberOfBasicBlocks, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetNumberOfBasicBlocks_1)638 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetNumberOfBasicBlocks_1)
639 {
640     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
641     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
642     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
643         g_implG->gGetNumberOfBasicBlocks(graph);
644         ASSERT_EQ(g_implG->gGetNumberOfBasicBlocks(graph), 5U);
645         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
646     });
647     g_impl->closeFile(file);
648 }
649 
650 // Test: test-kind=api, api=GraphApiImpl::bbGetId, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetId_1)651 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetId_1)
652 {
653     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
654     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
655     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
656         auto *start = g_implG->gGetStartBasicBlock(graph);
657         ASSERT_EQ(g_implG->bbGetId(start), 3U);
658         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
659     });
660     g_impl->closeFile(file);
661 }
662 
663 // Test: test-kind=api, api=GraphApiImpl::bbGetPredBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetPredBlock_1)664 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetPredBlock_1)
665 {
666     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
667     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
668     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
669         auto *start = g_implG->gGetStartBasicBlock(graph);
670         auto *bb = g_implG->bbGetSuccBlock(start, 0);
671         ASSERT_EQ(g_implG->bbGetPredBlock(bb, 0), helpers::BBgetPredBlocks(bb)[0]);
672         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
673     });
674     g_impl->closeFile(file);
675 }
676 
677 // Test: test-kind=api, api=GraphApiImpl::bbInsertSuccBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBinsertSuccBlock_1)678 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBinsertSuccBlock_1)
679 {
680     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
681     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
682     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
683         auto *start = g_implG->gGetStartBasicBlock(graph);
684         auto *bb = g_implG->bbGetSuccBlock(start, 0);
685         auto *empty = g_implG->bbCreateEmpty(graph);
686         g_implG->bbInsertSuccBlock(bb, empty, 2U);
687         ASSERT_EQ(g_implG->bbGetSuccBlock(bb, 2U), helpers::BBgetSuccBlocks(bb)[2U]);
688         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
689         g_implG->bbDisconnectSuccBlock(bb, 2U);
690     });
691     g_impl->closeFile(file);
692 }
693 
694 // Test: test-kind=api, api=GraphApiImpl::bbAppendSuccBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBappendSuccBlock_1)695 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBappendSuccBlock_1)
696 {
697     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
698     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
699     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
700         auto *start = g_implG->gGetStartBasicBlock(graph);
701         auto *bb = g_implG->bbGetSuccBlock(start, 0);
702         auto *empty = g_implG->bbCreateEmpty(graph);
703         g_implG->bbAppendSuccBlock(bb, empty);
704         ASSERT_EQ(g_implG->bbGetSuccBlock(bb, 2U), helpers::BBgetSuccBlocks(bb)[2U]);
705         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
706         g_implG->bbDisconnectSuccBlock(bb, g_implG->bbGetSuccBlockCount(bb) - 1);
707     });
708     g_impl->closeFile(file);
709 }
710 
711 // Test: test-kind=api, api=GraphApiImpl::bbRemoveAllInsts, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,bbRemoveAllInsts_1)712 TEST_F(LibAbcKitBasicBlocksDynamicTest, bbRemoveAllInsts_1)
713 {
714     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
715     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
716     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
717         auto *empty = g_implG->bbCreateEmpty(graph);
718         auto *constInst = g_implG->gFindOrCreateConstantI64(graph, 1U);
719         auto *newInst = g_dynG->iCreateNeg(graph, constInst);
720         g_implG->bbAddInstFront(empty, newInst);
721         ASSERT_EQ(g_implG->bbGetNumberOfInstructions(empty), 1);
722         g_implG->bbRemoveAllInsts(empty);
723         ASSERT_EQ(g_implG->bbGetNumberOfInstructions(empty), 0);
724         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
725     });
726     g_impl->closeFile(file);
727 }
728 
729 // Test: test-kind=api, api=GraphApiImpl::bbIsLoopPrehead, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisLoopPrehead_1)730 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisLoopPrehead_1)
731 {
732     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
733     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
734     helpers::TransformMethod(file, "test4", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
735         auto *start = g_implG->gGetStartBasicBlock(graph);
736         auto *bb = g_implG->bbGetSuccBlock(start, 0);
737         ASSERT_TRUE(g_implG->bbIsLoopPrehead(bb));
738         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
739     });
740     g_impl->closeFile(file);
741 }
742 
743 // Test: test-kind=api, api=GraphApiImpl::bbIsLoopHead, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisLoopHead_1)744 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisLoopHead_1)
745 {
746     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
747     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
748     helpers::TransformMethod(file, "test4", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
749         auto *start = g_implG->gGetStartBasicBlock(graph);
750         auto *bb = g_implG->bbGetSuccBlock(start, 0);
751         auto *bb2 = g_implG->bbGetSuccBlock(bb, 0);
752         ASSERT_TRUE(g_implG->bbIsLoopHead(bb2));
753         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
754     });
755     g_impl->closeFile(file);
756 }
757 
758 // Test: test-kind=api, api=GraphApiImpl::bbSplitBlockAfterInstruction, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBsplitBlockAfterInstruction_1)759 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBsplitBlockAfterInstruction_1)
760 {
761     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
762     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
763     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
764         auto *start = g_implG->gGetStartBasicBlock(graph);
765         auto *bb = g_implG->bbGetSuccBlock(start, 0);
766         auto *bb2 = g_implG->bbGetSuccBlock(bb, 0);
767         auto *inst = g_implG->bbGetFirstInst(bb2);
768         ASSERT_EQ(g_implG->gGetNumberOfBasicBlocks(graph), 5U);
769         auto *newBb = g_implG->bbSplitBlockAfterInstruction(bb2, inst, false);
770         ASSERT_EQ(g_implG->gGetNumberOfBasicBlocks(graph), 6U);
771         g_implG->bbAppendSuccBlock(bb2, newBb);
772         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
773     });
774     g_impl->closeFile(file);
775 }
776 
777 // Test: test-kind=api, api=GraphApiImpl::bbCheckDominance, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBcheckDominance_1)778 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBcheckDominance_1)
779 {
780     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
781     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
782     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
783         auto *start = g_implG->gGetStartBasicBlock(graph);
784         auto *bb = g_implG->bbGetSuccBlock(start, 0);
785         ASSERT_TRUE(g_implG->bbCheckDominance(bb, start));
786         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
787     });
788     g_impl->closeFile(file);
789 }
790 
791 // Test: test-kind=api, api=GraphApiImpl::bbVisitSuccBlocks, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBvisitSuccBlocksDynamic)792 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBvisitSuccBlocksDynamic)
793 {
794     auto output = helpers::ExecuteDynamicAbc(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/visit_succ_dynamic.abc",
795                                              "visit_succ_dynamic");
796     EXPECT_TRUE(helpers::Match(output, "0\n1\n"));
797     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
798         AbckitBasicBlock *startBB = g_implG->gGetStartBasicBlock(graph);
799         AbckitBasicBlock *ifBB = g_implG->bbGetSuccBlock(startBB, 0);
800         std::vector<AbckitBasicBlock *> succBBs;
801         struct VisitData {
802             const AbckitIsaApiDynamic *gDynG;
803             AbckitGraph *graph;
804             int newPrintInt;
805         } data {g_dynG, graph, 42};
806 
807         // CC-OFFNXT(G.FMT.02)
808         auto simpleCb = [](AbckitBasicBlock *succBasicBlock, void *d) -> bool {
809             // CC-OFFNXT(G.FMT.02)
810             auto *gDynG = static_cast<struct VisitData *>(d)->gDynG;
811             auto *graph = static_cast<struct VisitData *>(d)->graph;
812             int newPrintInt = static_cast<struct VisitData *>(d)->newPrintInt++;
813             auto *curInst = g_implG->bbGetFirstInst(succBasicBlock);
814             while (curInst != nullptr &&
815                    // CC-OFFNXT(G.FMT.02)
816                    gDynG->iGetOpcode(curInst) != ABCKIT_ISA_API_DYNAMIC_OPCODE_CALLARG1) {
817                 curInst = g_implG->iGetNext(curInst);
818             }
819             if (curInst == nullptr) {
820                 return false;
821             }
822             g_implG->iSetInput(curInst, g_implG->gFindOrCreateConstantU64(graph, newPrintInt), 1);
823             return true;
824         };
825 
826         // CC-OFFNXT(G.FMT.02)
827         g_implG->bbVisitSuccBlocks(ifBB, &data, simpleCb);
828     };
829     helpers::TransformMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/visit_succ_dynamic.abc",
830                              ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/visit_succ_dynamic_modified.abc",
831                              "visitSuccBlocks", cb);
832     output = helpers::ExecuteDynamicAbc(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/visit_succ_dynamic_modified.abc",
833                                         "visit_succ_dynamic");
834     EXPECT_TRUE(helpers::Match(output, "43\n42\n"));
835 }
836 
837 // Test: test-kind=api, api=GraphApiImpl::bbIsTry, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisTry)838 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisTry)
839 {
840     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
841         auto *startBB = g_implG->gGetStartBasicBlock(graph);
842         AbckitBasicBlock *tryBB = g_implG->bbGetSuccBlock(g_implG->bbGetSuccBlock(startBB, 0), 0);
843         // CC-OFFNXT(G.FMT.02)
844         ASSERT_TRUE(g_implG->bbIsTry(tryBB));
845     };
846     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
847 }
848 
849 // Test: test-kind=api, api=GraphApiImpl::bbIsTryBegin, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisTryBegin)850 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisTryBegin)
851 {
852     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
853         auto *startBB = g_implG->gGetStartBasicBlock(graph);
854         AbckitBasicBlock *tryBegin = g_implG->bbGetSuccBlock(startBB, 0);
855         ASSERT_TRUE(g_implG->bbIsTryBegin(tryBegin));
856     };
857     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
858 }
859 
860 // Test: test-kind=api, api=GraphApiImpl::bbIsTryEnd, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisTryEnd)861 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisTryEnd)
862 {
863     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
864         auto *endBB = g_implG->gGetEndBasicBlock(graph);
865         AbckitBasicBlock *tryEnd = g_implG->bbGetPredBlock(endBB, 0);
866         ASSERT_TRUE(g_implG->bbIsTryEnd(tryEnd));
867     };
868     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
869 }
870 
871 // Test: test-kind=api, api=GraphApiImpl::bbIsCatchBegin, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisCatchBegin)872 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisCatchBegin)
873 {
874     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
875         auto *startBB = g_implG->gGetStartBasicBlock(graph);
876         AbckitBasicBlock *tryBegin = g_implG->bbGetSuccBlock(startBB, 0);
877         AbckitBasicBlock *catchBegin = g_implG->bbGetSuccBlock(tryBegin, 1);
878         ASSERT_TRUE(g_implG->bbIsCatchBegin(catchBegin));
879     };
880     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
881 }
882 
883 // Test: test-kind=api, api=GraphApiImpl::bbIsCatch, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisCatch)884 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisCatch)
885 {
886     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
887         auto *endBB = g_implG->gGetEndBasicBlock(graph);
888         AbckitBasicBlock *tryEnd = g_implG->bbGetPredBlock(endBB, 0);
889         AbckitBasicBlock *catchBB = g_implG->bbGetSuccBlock(tryEnd, 1);
890         ASSERT_TRUE(g_implG->bbIsCatch(catchBB));
891     };
892     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
893 }
894 
895 }  // namespace libabckit::test
896 
897 // NOLINTEND(readability-magic-numbers)
898