• 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 "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/src/include_v2/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::bbGetSuccBlockCount, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetSuccBlockCount_1)501 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetSuccBlockCount_1)
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 
508         ASSERT_EQ(g_implG->bbGetSuccBlockCount(start), 1);
509         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
510     });
511     g_impl->closeFile(file);
512 }
513 
514 // Test: test-kind=api, api=GraphApiImpl::bbGetPredBlockCount, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetPredBlockCount_1)515 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetPredBlockCount_1)
516 {
517     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
518     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
519     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
520         auto *start = g_implG->gGetStartBasicBlock(graph);
521         auto *bb = helpers::BBgetSuccBlocks(start)[0];
522 
523         ASSERT_EQ(g_implG->bbGetPredBlockCount(bb), 1);
524         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
525     });
526     g_impl->closeFile(file);
527 }
528 
529 // Test: test-kind=api, api=GraphApiImpl::bbDump, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBdump_1)530 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBdump_1)
531 {
532     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
533     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
534     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
535         auto *start = g_implG->gGetStartBasicBlock(graph);
536         LIBABCKIT_LOG_DUMP(g_implG->bbDump(start, 0), DEBUG);
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::bbGetNumberOfInstructions, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetNumberOfInstructions_1)543 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetNumberOfInstructions_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         auto *bb = helpers::BBgetSuccBlocks(start)[0];
550         ASSERT_EQ(g_implG->bbGetNumberOfInstructions(bb), 1U);
551         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
552     });
553     g_impl->closeFile(file);
554 }
555 
556 // Test: test-kind=api, api=GraphApiImpl::gGetBasicBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetBasicBlock_1)557 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetBasicBlock_1)
558 {
559     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
560     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
561     helpers::TransformMethod(file, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
562         auto *bb = g_implG->gGetBasicBlock(graph, 1);
563         ASSERT_EQ(bb, g_implG->gGetStartBasicBlock(graph));
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=negative
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetBasicBlockBigId)570 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetBasicBlockBigId)
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 bbVectorSize = g_implG->gGetNumberOfBasicBlocks(graph);
576         auto *bb = g_implG->gGetBasicBlock(graph, bbVectorSize + 1);
577         ASSERT_EQ(bb, nullptr);
578         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_BAD_ARGUMENT);
579     });
580     g_impl->closeFile(file);
581 }
582 
583 // Test: test-kind=api, api=GraphApiImpl::gGetParameter, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetParameter_1)584 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetParameter_1)
585 {
586     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
587     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
588     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
589         auto *start = g_implG->gGetStartBasicBlock(graph);
590         auto *inst = g_implG->bbGetFirstInst(start);
591         ASSERT_EQ(inst, g_implG->gGetParameter(graph, 0));
592         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
593     });
594     g_impl->closeFile(file);
595 }
596 
597 // Test: test-kind=api, api=GraphApiImpl::gGetParameter, abc-kind=ArkTS1, category=negative
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetParameterBigId)598 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetParameterBigId)
599 {
600     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
601     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
602     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
603         auto size = g_implG->gGetNumberOfParameters(graph);
604         auto *inst = g_implG->gGetParameter(graph, size + 1);
605         ASSERT_EQ(inst, nullptr);
606         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_BAD_ARGUMENT);
607     });
608     g_impl->closeFile(file);
609 }
610 
611 // Test: test-kind=api, api=GraphApiImpl::gGetNumberOfParameters, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetNumberOfParameters)612 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetNumberOfParameters)
613 {
614     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
615     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
616     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
617         uint32_t num = g_implG->gGetNumberOfParameters(graph);
618         ASSERT_EQ(num, 4U);
619         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
620     });
621     g_impl->closeFile(file);
622 }
623 
624 // Test: test-kind=api, api=GraphApiImpl::gGetNumberOfBasicBlocks, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,GgetNumberOfBasicBlocks_1)625 TEST_F(LibAbcKitBasicBlocksDynamicTest, GgetNumberOfBasicBlocks_1)
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         g_implG->gGetNumberOfBasicBlocks(graph);
631         ASSERT_EQ(g_implG->gGetNumberOfBasicBlocks(graph), 5U);
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::bbGetId, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetId_1)638 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetId_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         auto *start = g_implG->gGetStartBasicBlock(graph);
644         ASSERT_EQ(g_implG->bbGetId(start), 3U);
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::bbGetPredBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBgetPredBlock_1)651 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBgetPredBlock_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, "test", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
656         auto *start = g_implG->gGetStartBasicBlock(graph);
657         auto *bb = g_implG->bbGetSuccBlock(start, 0);
658         ASSERT_EQ(g_implG->bbGetPredBlock(bb, 0), helpers::BBgetPredBlocks(bb)[0]);
659         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
660     });
661     g_impl->closeFile(file);
662 }
663 
664 // Test: test-kind=api, api=GraphApiImpl::bbInsertSuccBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBinsertSuccBlock_1)665 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBinsertSuccBlock_1)
666 {
667     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
668     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
669     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
670         auto *start = g_implG->gGetStartBasicBlock(graph);
671         auto *bb = g_implG->bbGetSuccBlock(start, 0);
672         auto *empty = g_implG->bbCreateEmpty(graph);
673         g_implG->bbInsertSuccBlock(bb, empty, 2U);
674         ASSERT_EQ(g_implG->bbGetSuccBlock(bb, 2U), helpers::BBgetSuccBlocks(bb)[2U]);
675         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
676         g_implG->bbDisconnectSuccBlock(bb, 2U);
677     });
678     g_impl->closeFile(file);
679 }
680 
681 // Test: test-kind=api, api=GraphApiImpl::bbAppendSuccBlock, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBappendSuccBlock_1)682 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBappendSuccBlock_1)
683 {
684     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
685     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
686     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
687         auto *start = g_implG->gGetStartBasicBlock(graph);
688         auto *bb = g_implG->bbGetSuccBlock(start, 0);
689         auto *empty = g_implG->bbCreateEmpty(graph);
690         g_implG->bbAppendSuccBlock(bb, empty);
691         ASSERT_EQ(g_implG->bbGetSuccBlock(bb, 2U), helpers::BBgetSuccBlocks(bb)[2U]);
692         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
693         g_implG->bbDisconnectSuccBlock(bb, g_implG->bbGetSuccBlockCount(bb) - 1);
694     });
695     g_impl->closeFile(file);
696 }
697 
698 // Test: test-kind=api, api=GraphApiImpl::bbRemoveAllInsts, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,bbRemoveAllInsts_1)699 TEST_F(LibAbcKitBasicBlocksDynamicTest, bbRemoveAllInsts_1)
700 {
701     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
702     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
703     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
704         auto *empty = g_implG->bbCreateEmpty(graph);
705         auto *constInst = g_implG->gFindOrCreateConstantI64(graph, 1U);
706         auto *newInst = g_dynG->iCreateNeg(graph, constInst);
707         g_implG->bbAddInstFront(empty, newInst);
708         ASSERT_EQ(g_implG->bbGetNumberOfInstructions(empty), 1);
709         g_implG->bbRemoveAllInsts(empty);
710         ASSERT_EQ(g_implG->bbGetNumberOfInstructions(empty), 0);
711         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
712     });
713     g_impl->closeFile(file);
714 }
715 
716 // Test: test-kind=api, api=GraphApiImpl::bbIsLoopPrehead, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisLoopPrehead_1)717 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisLoopPrehead_1)
718 {
719     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
720     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
721     helpers::TransformMethod(file, "test4", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
722         auto *start = g_implG->gGetStartBasicBlock(graph);
723         auto *bb = g_implG->bbGetSuccBlock(start, 0);
724         ASSERT_TRUE(g_implG->bbIsLoopPrehead(bb));
725         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
726     });
727     g_impl->closeFile(file);
728 }
729 
730 // Test: test-kind=api, api=GraphApiImpl::bbIsLoopHead, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisLoopHead_1)731 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisLoopHead_1)
732 {
733     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
734     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
735     helpers::TransformMethod(file, "test4", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
736         auto *start = g_implG->gGetStartBasicBlock(graph);
737         auto *bb = g_implG->bbGetSuccBlock(start, 0);
738         auto *bb2 = g_implG->bbGetSuccBlock(bb, 0);
739         ASSERT_TRUE(g_implG->bbIsLoopHead(bb2));
740         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
741     });
742     g_impl->closeFile(file);
743 }
744 
745 // Test: test-kind=api, api=GraphApiImpl::bbSplitBlockAfterInstruction, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBsplitBlockAfterInstruction_1)746 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBsplitBlockAfterInstruction_1)
747 {
748     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
749     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
750     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
751         auto *start = g_implG->gGetStartBasicBlock(graph);
752         auto *bb = g_implG->bbGetSuccBlock(start, 0);
753         auto *bb2 = g_implG->bbGetSuccBlock(bb, 0);
754         auto *inst = g_implG->bbGetFirstInst(bb2);
755         ASSERT_EQ(g_implG->gGetNumberOfBasicBlocks(graph), 5U);
756         auto *newBb = g_implG->bbSplitBlockAfterInstruction(bb2, inst, false);
757         ASSERT_EQ(g_implG->gGetNumberOfBasicBlocks(graph), 6U);
758         g_implG->bbAppendSuccBlock(bb2, newBb);
759         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
760     });
761     g_impl->closeFile(file);
762 }
763 
764 // Test: test-kind=api, api=GraphApiImpl::bbCheckDominance, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBcheckDominance_1)765 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBcheckDominance_1)
766 {
767     AbckitFile *file = g_impl->openAbc(CREATE_EMPTY_INPUT_PATH, strlen(CREATE_EMPTY_INPUT_PATH));
768     ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
769     helpers::TransformMethod(file, "test2", [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
770         auto *start = g_implG->gGetStartBasicBlock(graph);
771         auto *bb = g_implG->bbGetSuccBlock(start, 0);
772         ASSERT_TRUE(g_implG->bbCheckDominance(bb, start));
773         ASSERT_EQ(g_impl->getLastError(), ABCKIT_STATUS_NO_ERROR);
774     });
775     g_impl->closeFile(file);
776 }
777 
778 // Test: test-kind=api, api=GraphApiImpl::bbVisitSuccBlocks, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBvisitSuccBlocksDynamic)779 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBvisitSuccBlocksDynamic)
780 {
781     auto output = helpers::ExecuteDynamicAbc(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/visit_succ_dynamic.abc",
782                                              "visit_succ_dynamic");
783     EXPECT_TRUE(helpers::Match(output, "0\n1\n"));
784     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
785         AbckitBasicBlock *startBB = g_implG->gGetStartBasicBlock(graph);
786         AbckitBasicBlock *ifBB = g_implG->bbGetSuccBlock(startBB, 0);
787         std::vector<AbckitBasicBlock *> succBBs;
788         struct VisitData {
789             const AbckitIsaApiDynamic *gDynG;
790             AbckitGraph *graph;
791             int newPrintInt;
792         } data {g_dynG, graph, 42};
793 
794         // CC-OFFNXT(G.FMT.02)
795         auto simpleCb = [](AbckitBasicBlock *succBasicBlock, void *d) -> bool {
796             // CC-OFFNXT(G.FMT.02)
797             auto *gDynG = static_cast<struct VisitData *>(d)->gDynG;
798             auto *graph = static_cast<struct VisitData *>(d)->graph;
799             int newPrintInt = static_cast<struct VisitData *>(d)->newPrintInt++;
800             auto *curInst = g_implG->bbGetFirstInst(succBasicBlock);
801             while (curInst != nullptr &&
802                    // CC-OFFNXT(G.FMT.02)
803                    gDynG->iGetOpcode(curInst) != ABCKIT_ISA_API_DYNAMIC_OPCODE_CALLARG1) {
804                 curInst = g_implG->iGetNext(curInst);
805             }
806             if (curInst == nullptr) {
807                 return false;
808             }
809             g_implG->iSetInput(curInst, g_implG->gFindOrCreateConstantU64(graph, newPrintInt), 1);
810             return true;
811         };
812 
813         // CC-OFFNXT(G.FMT.02)
814         g_implG->bbVisitSuccBlocks(ifBB, &data, simpleCb);
815     };
816     helpers::TransformMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/visit_succ_dynamic.abc",
817                              ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/visit_succ_dynamic_modified.abc",
818                              "visitSuccBlocks", cb);
819     output = helpers::ExecuteDynamicAbc(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/visit_succ_dynamic_modified.abc",
820                                         "visit_succ_dynamic");
821     EXPECT_TRUE(helpers::Match(output, "43\n42\n"));
822 }
823 
824 // Test: test-kind=api, api=GraphApiImpl::bbIsTry, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisTry)825 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisTry)
826 {
827     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
828         auto *startBB = g_implG->gGetStartBasicBlock(graph);
829         AbckitBasicBlock *tryBB = g_implG->bbGetSuccBlock(g_implG->bbGetSuccBlock(startBB, 0), 0);
830         // CC-OFFNXT(G.FMT.02)
831         ASSERT_TRUE(g_implG->bbIsTry(tryBB));
832     };
833     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
834 }
835 
836 // Test: test-kind=api, api=GraphApiImpl::bbIsTryBegin, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisTryBegin)837 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisTryBegin)
838 {
839     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
840         auto *startBB = g_implG->gGetStartBasicBlock(graph);
841         AbckitBasicBlock *tryBegin = g_implG->bbGetSuccBlock(startBB, 0);
842         ASSERT_TRUE(g_implG->bbIsTryBegin(tryBegin));
843     };
844     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
845 }
846 
847 // Test: test-kind=api, api=GraphApiImpl::bbIsTryEnd, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisTryEnd)848 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisTryEnd)
849 {
850     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
851         auto *endBB = g_implG->gGetEndBasicBlock(graph);
852         AbckitBasicBlock *tryEnd = g_implG->bbGetPredBlock(endBB, 0);
853         ASSERT_TRUE(g_implG->bbIsTryEnd(tryEnd));
854     };
855     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
856 }
857 
858 // Test: test-kind=api, api=GraphApiImpl::bbIsCatchBegin, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisCatchBegin)859 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisCatchBegin)
860 {
861     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
862         auto *startBB = g_implG->gGetStartBasicBlock(graph);
863         AbckitBasicBlock *tryBegin = g_implG->bbGetSuccBlock(startBB, 0);
864         AbckitBasicBlock *catchBegin = g_implG->bbGetSuccBlock(tryBegin, 1);
865         ASSERT_TRUE(g_implG->bbIsCatchBegin(catchBegin));
866     };
867     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
868 }
869 
870 // Test: test-kind=api, api=GraphApiImpl::bbIsCatch, abc-kind=ArkTS1, category=positive, extension=c
TEST_F(LibAbcKitBasicBlocksDynamicTest,BBisCatch)871 TEST_F(LibAbcKitBasicBlocksDynamicTest, BBisCatch)
872 {
873     auto cb = [](AbckitFile *, AbckitCoreFunction *, AbckitGraph *graph) {
874         auto *endBB = g_implG->gGetEndBasicBlock(graph);
875         AbckitBasicBlock *tryEnd = g_implG->bbGetPredBlock(endBB, 0);
876         AbckitBasicBlock *catchBB = g_implG->bbGetSuccBlock(tryEnd, 1);
877         ASSERT_TRUE(g_implG->bbIsCatch(catchBB));
878     };
879     helpers::InspectMethod(ABCKIT_ABC_DIR "ut/ir_core/basic_blocks/js_src/try_catch_blocks_dynamic.abc", "test", cb);
880 }
881 
882 }  // namespace libabckit::test
883 
884 // NOLINTEND(readability-magic-numbers)
885