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 "../check_mock.h"
17 #include "../../../src/mock/mock_values.h"
18 #include "../cpp_helpers_mock.h"
19 #include "include/cpp/headers/basic_block.h"
20
21 #include <gtest/gtest.h>
22
23 namespace libabckit::test {
24
25 class LibAbcKitCppMockTestBasicBlock : public ::testing::Test {};
26
27 // Test: test-kind=mock, api=BasicBlock::VisitSuccBlocks, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_VisitSuccBlocks)28 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_VisitSuccBlocks)
29 {
30 ASSERT_TRUE(CheckMockedStackEmpty());
31 {
32 abckit::File f(DEFAULT_PATH);
33 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
34 abckit::mock::helpers::GetMockBasicBlock(f).VisitSuccBlocks(
35 []([[maybe_unused]] const abckit::BasicBlock &bb) {});
36 ASSERT_TRUE(CheckMockedApi("BBVisitSuccBlocks"));
37 }
38 ASSERT_TRUE(CheckMockedApi("CloseFile"));
39 ASSERT_TRUE(CheckMockedStackEmpty());
40 }
41
42 // Test: test-kind=mock, api=BasicBlock::VisitPredBlocks, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_VisitPredBlocks)43 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_VisitPredBlocks)
44 {
45 ASSERT_TRUE(CheckMockedStackEmpty());
46 {
47 abckit::File f(DEFAULT_PATH);
48 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
49 abckit::mock::helpers::GetMockBasicBlock(f).VisitPredBlocks(
50 []([[maybe_unused]] const abckit::BasicBlock &bb) { return false; });
51 ASSERT_TRUE(CheckMockedApi("BBVisitPredBlocks"));
52 }
53 ASSERT_TRUE(CheckMockedApi("CloseFile"));
54 ASSERT_TRUE(CheckMockedStackEmpty());
55 }
56
57 // Test: test-kind=mock, api=BasicBlock::GetSuccCount, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetSuccCount)58 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetSuccCount)
59 {
60 ASSERT_TRUE(CheckMockedStackEmpty());
61 {
62 abckit::File f(DEFAULT_PATH);
63 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
64 abckit::mock::helpers::GetMockBasicBlock(f).GetSuccCount();
65 ASSERT_TRUE(CheckMockedApi("BBGetSuccBlockCount"));
66 }
67 ASSERT_TRUE(CheckMockedApi("CloseFile"));
68 ASSERT_TRUE(CheckMockedStackEmpty());
69 }
70
71 // Test: test-kind=mock, api=BasicBlock::GetSuccByIdx, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetSuccByIdx)72 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetSuccByIdx)
73 {
74 ASSERT_TRUE(CheckMockedStackEmpty());
75 {
76 abckit::File f(DEFAULT_PATH);
77 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
78 abckit::mock::helpers::GetMockBasicBlock(f).GetSuccByIdx(DEFAULT_U32);
79 ASSERT_TRUE(CheckMockedApi("BBGetSuccBlock"));
80 }
81 ASSERT_TRUE(CheckMockedApi("CloseFile"));
82 ASSERT_TRUE(CheckMockedStackEmpty());
83 }
84
85 // Test: test-kind=mock, api=BasicBlock::GetSuccs, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetSuccs)86 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetSuccs)
87 {
88 ASSERT_TRUE(CheckMockedStackEmpty());
89 {
90 abckit::File f(DEFAULT_PATH);
91 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
92 abckit::mock::helpers::GetMockBasicBlock(f).GetSuccs();
93 ASSERT_TRUE(CheckMockedApi("BBVisitSuccBlocks"));
94 }
95 ASSERT_TRUE(CheckMockedApi("CloseFile"));
96 ASSERT_TRUE(CheckMockedStackEmpty());
97 }
98
99 // Test: test-kind=mock, api=BasicBlock::GetPreds, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetPreds)100 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetPreds)
101 {
102 ASSERT_TRUE(CheckMockedStackEmpty());
103 {
104 abckit::File f(DEFAULT_PATH);
105 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
106 abckit::mock::helpers::GetMockBasicBlock(f).GetPreds();
107 ASSERT_TRUE(CheckMockedApi("BBVisitPredBlocks"));
108 }
109 ASSERT_TRUE(CheckMockedApi("CloseFile"));
110 ASSERT_TRUE(CheckMockedStackEmpty());
111 }
112
113 // Test: test-kind=mock, api=BasicBlock::AddInstFront, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_AddInstFront)114 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_AddInstFront)
115 {
116 ASSERT_TRUE(CheckMockedStackEmpty());
117 {
118 abckit::File f(DEFAULT_PATH);
119 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
120 abckit::mock::helpers::GetMockBasicBlock(f).AddInstFront(abckit::mock::helpers::GetMockInstruction(f));
121 ASSERT_TRUE(CheckMockedApi("BBAddInstFront"));
122 }
123 ASSERT_TRUE(CheckMockedApi("CloseFile"));
124 ASSERT_TRUE(CheckMockedStackEmpty());
125 }
126
127 // Test: test-kind=mock, api=BasicBlock::AddInstBack, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_AddInstBack)128 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_AddInstBack)
129 {
130 ASSERT_TRUE(CheckMockedStackEmpty());
131 {
132 abckit::File f(DEFAULT_PATH);
133 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
134 abckit::mock::helpers::GetMockBasicBlock(f).AddInstBack(abckit::mock::helpers::GetMockInstruction(f));
135 ASSERT_TRUE(CheckMockedApi("BBAddInstBack"));
136 }
137 ASSERT_TRUE(CheckMockedApi("CloseFile"));
138 ASSERT_TRUE(CheckMockedStackEmpty());
139 }
140
141 // Test: test-kind=mock, api=BasicBlock::GetFirstInst, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetFirstInst)142 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetFirstInst)
143 {
144 ASSERT_TRUE(CheckMockedStackEmpty());
145 {
146 abckit::File f(DEFAULT_PATH);
147 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
148 abckit::mock::helpers::GetMockBasicBlock(f).GetFirstInst();
149 ASSERT_TRUE(CheckMockedApi("BBGetFirstInst"));
150 }
151 ASSERT_TRUE(CheckMockedApi("CloseFile"));
152 ASSERT_TRUE(CheckMockedStackEmpty());
153 }
154
155 // Test: test-kind=mock, api=BasicBlock::GetLastInst, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetLastInst)156 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetLastInst)
157 {
158 ASSERT_TRUE(CheckMockedStackEmpty());
159 {
160 abckit::File f(DEFAULT_PATH);
161 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
162 abckit::mock::helpers::GetMockBasicBlock(f).GetLastInst();
163 ASSERT_TRUE(CheckMockedApi("BBGetLastInst"));
164 }
165 ASSERT_TRUE(CheckMockedApi("CloseFile"));
166 ASSERT_TRUE(CheckMockedStackEmpty());
167 }
168
169 // Test: test-kind=mock, api=BasicBlock::GetId, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetId)170 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetId)
171 {
172 ASSERT_TRUE(CheckMockedStackEmpty());
173 {
174 abckit::File f(DEFAULT_PATH);
175 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
176 abckit::mock::helpers::GetMockBasicBlock(f).GetId();
177 ASSERT_TRUE(CheckMockedApi("BBGetId"));
178 }
179 ASSERT_TRUE(CheckMockedApi("CloseFile"));
180 ASSERT_TRUE(CheckMockedStackEmpty());
181 }
182
183 // Test: test-kind=mock, api=BasicBlock::GetGraph, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetGraph)184 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetGraph)
185 {
186 ASSERT_TRUE(CheckMockedStackEmpty());
187 {
188 abckit::File f(DEFAULT_PATH);
189 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
190 abckit::mock::helpers::GetMockBasicBlock(f).GetGraph();
191 }
192 ASSERT_TRUE(CheckMockedApi("CloseFile"));
193 ASSERT_TRUE(CheckMockedStackEmpty());
194 }
195
196 // Test: test-kind=mock, api=BasicBlock::GetPredBlockCount, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetPredBlockCount)197 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetPredBlockCount)
198 {
199 ASSERT_TRUE(CheckMockedStackEmpty());
200 {
201 abckit::File f(DEFAULT_PATH);
202 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
203 abckit::mock::helpers::GetMockBasicBlock(f).GetPredBlockCount();
204 ASSERT_TRUE(CheckMockedApi("BBGetPredBlockCount"));
205 }
206 ASSERT_TRUE(CheckMockedApi("CloseFile"));
207 ASSERT_TRUE(CheckMockedStackEmpty());
208 }
209
210 // Test: test-kind=mock, api=BasicBlock::GetPredBlock, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetPredBlock)211 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetPredBlock)
212 {
213 ASSERT_TRUE(CheckMockedStackEmpty());
214 {
215 abckit::File f(DEFAULT_PATH);
216 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
217 abckit::mock::helpers::GetMockBasicBlock(f).GetPredBlock(DEFAULT_U32);
218 ASSERT_TRUE(CheckMockedApi("BBGetPredBlock"));
219 }
220 ASSERT_TRUE(CheckMockedApi("CloseFile"));
221 ASSERT_TRUE(CheckMockedStackEmpty());
222 }
223
224 // Test: test-kind=mock, api=BasicBlock::GetSuccBlockCount, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetSuccBlockCount)225 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetSuccBlockCount)
226 {
227 ASSERT_TRUE(CheckMockedStackEmpty());
228 {
229 abckit::File f(DEFAULT_PATH);
230 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
231 abckit::mock::helpers::GetMockBasicBlock(f).GetSuccBlockCount();
232 ASSERT_TRUE(CheckMockedApi("BBGetSuccBlockCount"));
233 }
234 ASSERT_TRUE(CheckMockedApi("CloseFile"));
235 ASSERT_TRUE(CheckMockedStackEmpty());
236 }
237
238 // Test: test-kind=mock, api=BasicBlock::GetSuccBlock, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetSuccBlock)239 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetSuccBlock)
240 {
241 ASSERT_TRUE(CheckMockedStackEmpty());
242 {
243 abckit::File f(DEFAULT_PATH);
244 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
245 abckit::mock::helpers::GetMockBasicBlock(f).GetSuccBlock(DEFAULT_U32);
246 ASSERT_TRUE(CheckMockedApi("BBGetSuccBlock"));
247 }
248 ASSERT_TRUE(CheckMockedApi("CloseFile"));
249 ASSERT_TRUE(CheckMockedStackEmpty());
250 }
251
252 // Test: test-kind=mock, api=BasicBlock::InsertSuccBlock, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_InsertSuccBlock)253 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_InsertSuccBlock)
254 {
255 ASSERT_TRUE(CheckMockedStackEmpty());
256 {
257 abckit::File f(DEFAULT_PATH);
258 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
259 auto bb = abckit::mock::helpers::GetMockBasicBlock(f);
260 abckit::mock::helpers::GetMockBasicBlock(f).InsertSuccBlock(bb, DEFAULT_U32);
261 ASSERT_TRUE(CheckMockedApi("BBInsertSuccBlock"));
262 }
263 ASSERT_TRUE(CheckMockedApi("CloseFile"));
264 ASSERT_TRUE(CheckMockedStackEmpty());
265 }
266
267 // Test: test-kind=mock, api=BasicBlock::AppendSuccBlock, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_AppendSuccBlock)268 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_AppendSuccBlock)
269 {
270 ASSERT_TRUE(CheckMockedStackEmpty());
271 {
272 abckit::File f(DEFAULT_PATH);
273 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
274 auto bb = abckit::mock::helpers::GetMockBasicBlock(f);
275 abckit::mock::helpers::GetMockBasicBlock(f).AppendSuccBlock(bb);
276 ASSERT_TRUE(CheckMockedApi("BBAppendSuccBlock"));
277 }
278 ASSERT_TRUE(CheckMockedApi("CloseFile"));
279 ASSERT_TRUE(CheckMockedStackEmpty());
280 }
281
282 // Test: test-kind=mock, api=BasicBlock::EraseSuccBlock, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_EraseSuccBlock)283 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_EraseSuccBlock)
284 {
285 ASSERT_TRUE(CheckMockedStackEmpty());
286 {
287 abckit::File f(DEFAULT_PATH);
288 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
289 abckit::mock::helpers::GetMockBasicBlock(f).EraseSuccBlock(DEFAULT_U32);
290 ASSERT_TRUE(CheckMockedApi("BBdisconnectSuccBlock"));
291 }
292 ASSERT_TRUE(CheckMockedApi("CloseFile"));
293 ASSERT_TRUE(CheckMockedStackEmpty());
294 }
295
296 // Test: test-kind=mock, api=BasicBlock::GetTrueBranch, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetTrueBranch)297 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetTrueBranch)
298 {
299 ASSERT_TRUE(CheckMockedStackEmpty());
300 {
301 abckit::File f(DEFAULT_PATH);
302 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
303 abckit::mock::helpers::GetMockBasicBlock(f).GetTrueBranch();
304 ASSERT_TRUE(CheckMockedApi("BBGetTrueBranch"));
305 }
306 ASSERT_TRUE(CheckMockedApi("CloseFile"));
307 ASSERT_TRUE(CheckMockedStackEmpty());
308 }
309
310 // Test: test-kind=mock, api=BasicBlock::GetFalseBranch, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetFalseBranch)311 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetFalseBranch)
312 {
313 ASSERT_TRUE(CheckMockedStackEmpty());
314 {
315 abckit::File f(DEFAULT_PATH);
316 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
317 abckit::mock::helpers::GetMockBasicBlock(f).GetFalseBranch();
318 ASSERT_TRUE(CheckMockedApi("BBGetFalseBranch"));
319 }
320 ASSERT_TRUE(CheckMockedApi("CloseFile"));
321 ASSERT_TRUE(CheckMockedStackEmpty());
322 }
323
324 // Test: test-kind=mock, api=BasicBlock::RemoveAllInsts, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_RemoveAllInsts)325 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_RemoveAllInsts)
326 {
327 ASSERT_TRUE(CheckMockedStackEmpty());
328 {
329 abckit::File f(DEFAULT_PATH);
330 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
331 abckit::mock::helpers::GetMockBasicBlock(f).RemoveAllInsts();
332 ASSERT_TRUE(CheckMockedApi("BBRemoveAllInsts"));
333 }
334 ASSERT_TRUE(CheckMockedApi("CloseFile"));
335 ASSERT_TRUE(CheckMockedStackEmpty());
336 }
337
338 // Test: test-kind=mock, api=BasicBlock::GetNumberOfInstructions, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetNumberOfInstructions)339 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetNumberOfInstructions)
340 {
341 ASSERT_TRUE(CheckMockedStackEmpty());
342 {
343 abckit::File f(DEFAULT_PATH);
344 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
345 abckit::mock::helpers::GetMockBasicBlock(f).GetNumberOfInstructions();
346 ASSERT_TRUE(CheckMockedApi("BBGetNumberOfInstructions"));
347 }
348 ASSERT_TRUE(CheckMockedApi("CloseFile"));
349 ASSERT_TRUE(CheckMockedStackEmpty());
350 }
351
352 // Test: test-kind=mock, api=BasicBlock::GetImmediateDominator, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_GetImmediateDominator)353 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_GetImmediateDominator)
354 {
355 ASSERT_TRUE(CheckMockedStackEmpty());
356 {
357 abckit::File f(DEFAULT_PATH);
358 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
359 abckit::mock::helpers::GetMockBasicBlock(f).GetImmediateDominator();
360 ASSERT_TRUE(CheckMockedApi("BBGetImmediateDominator"));
361 }
362 ASSERT_TRUE(CheckMockedApi("CloseFile"));
363 ASSERT_TRUE(CheckMockedStackEmpty());
364 }
365
366 // Test: test-kind=mock, api=BasicBlock::CheckDominance, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_CheckDominance)367 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_CheckDominance)
368 {
369 ASSERT_TRUE(CheckMockedStackEmpty());
370 {
371 abckit::File f(DEFAULT_PATH);
372 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
373 auto bb = abckit::mock::helpers::GetMockBasicBlock(f);
374 abckit::mock::helpers::GetMockBasicBlock(f).CheckDominance(bb);
375 ASSERT_TRUE(CheckMockedApi("BBCheckDominance"));
376 }
377 ASSERT_TRUE(CheckMockedApi("CloseFile"));
378 ASSERT_TRUE(CheckMockedStackEmpty());
379 }
380
381 // Test: test-kind=mock, api=BasicBlock::VisitDominatedBlocks, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_VisitDominatedBlocks)382 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_VisitDominatedBlocks)
383 {
384 ASSERT_TRUE(CheckMockedStackEmpty());
385 {
386 abckit::File f(DEFAULT_PATH);
387 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
388 abckit::mock::helpers::GetMockBasicBlock(f).VisitDominatedBlocks(
389 []([[maybe_unused]] const abckit::BasicBlock &bb) { return false; });
390 ASSERT_TRUE(CheckMockedApi("BBVisitDominatedBlocks"));
391 }
392 ASSERT_TRUE(CheckMockedApi("CloseFile"));
393 ASSERT_TRUE(CheckMockedStackEmpty());
394 }
395
396 // Test: test-kind=mock, api=BasicBlock::IsStart, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsStart)397 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsStart)
398 {
399 ASSERT_TRUE(CheckMockedStackEmpty());
400 {
401 abckit::File f(DEFAULT_PATH);
402 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
403 abckit::mock::helpers::GetMockBasicBlock(f).IsStart();
404 ASSERT_TRUE(CheckMockedApi("BBIsStart"));
405 }
406 ASSERT_TRUE(CheckMockedApi("CloseFile"));
407 ASSERT_TRUE(CheckMockedStackEmpty());
408 }
409
410 // Test: test-kind=mock, api=BasicBlock::IsEnd, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsEnd)411 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsEnd)
412 {
413 ASSERT_TRUE(CheckMockedStackEmpty());
414 {
415 abckit::File f(DEFAULT_PATH);
416 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
417 abckit::mock::helpers::GetMockBasicBlock(f).IsEnd();
418 ASSERT_TRUE(CheckMockedApi("BBIsEnd"));
419 }
420 ASSERT_TRUE(CheckMockedApi("CloseFile"));
421 ASSERT_TRUE(CheckMockedStackEmpty());
422 }
423
424 // Test: test-kind=mock, api=BasicBlock::IsLoopHead, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsLoopHead)425 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsLoopHead)
426 {
427 ASSERT_TRUE(CheckMockedStackEmpty());
428 {
429 abckit::File f(DEFAULT_PATH);
430 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
431 abckit::mock::helpers::GetMockBasicBlock(f).IsLoopHead();
432 ASSERT_TRUE(CheckMockedApi("BBIsLoopHead"));
433 }
434 ASSERT_TRUE(CheckMockedApi("CloseFile"));
435 ASSERT_TRUE(CheckMockedStackEmpty());
436 }
437
438 // Test: test-kind=mock, api=BasicBlock::IsLoopPrehead, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsLoopPrehead)439 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsLoopPrehead)
440 {
441 ASSERT_TRUE(CheckMockedStackEmpty());
442 {
443 abckit::File f(DEFAULT_PATH);
444 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
445 abckit::mock::helpers::GetMockBasicBlock(f).IsLoopPrehead();
446 ASSERT_TRUE(CheckMockedApi("BBIsLoopPrehead"));
447 }
448 ASSERT_TRUE(CheckMockedApi("CloseFile"));
449 ASSERT_TRUE(CheckMockedStackEmpty());
450 }
451
452 // Test: test-kind=mock, api=BasicBlock::IsTryBegin, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsTryBegin)453 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsTryBegin)
454 {
455 ASSERT_TRUE(CheckMockedStackEmpty());
456 {
457 abckit::File f(DEFAULT_PATH);
458 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
459 abckit::mock::helpers::GetMockBasicBlock(f).IsTryBegin();
460 ASSERT_TRUE(CheckMockedApi("BBIsTryBegin"));
461 }
462 ASSERT_TRUE(CheckMockedApi("CloseFile"));
463 ASSERT_TRUE(CheckMockedStackEmpty());
464 }
465
466 // Test: test-kind=mock, api=BasicBlock::IsTry, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsTry)467 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsTry)
468 {
469 ASSERT_TRUE(CheckMockedStackEmpty());
470 {
471 abckit::File f(DEFAULT_PATH);
472 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
473 abckit::mock::helpers::GetMockBasicBlock(f).IsTry();
474 ASSERT_TRUE(CheckMockedApi("BBIsTry"));
475 }
476 ASSERT_TRUE(CheckMockedApi("CloseFile"));
477 ASSERT_TRUE(CheckMockedStackEmpty());
478 }
479
480 // Test: test-kind=mock, api=BasicBlock::IsTryEnd, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsTryEnd)481 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsTryEnd)
482 {
483 ASSERT_TRUE(CheckMockedStackEmpty());
484 {
485 abckit::File f(DEFAULT_PATH);
486 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
487 abckit::mock::helpers::GetMockBasicBlock(f).IsTryEnd();
488 ASSERT_TRUE(CheckMockedApi("BBIsTryEnd"));
489 }
490 ASSERT_TRUE(CheckMockedApi("CloseFile"));
491 ASSERT_TRUE(CheckMockedStackEmpty());
492 }
493
494 // Test: test-kind=mock, api=BasicBlock::IsCatchBegin, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsCatchBegin)495 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsCatchBegin)
496 {
497 ASSERT_TRUE(CheckMockedStackEmpty());
498 {
499 abckit::File f(DEFAULT_PATH);
500 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
501 abckit::mock::helpers::GetMockBasicBlock(f).IsCatchBegin();
502 ASSERT_TRUE(CheckMockedApi("BBIsCatchBegin"));
503 }
504 ASSERT_TRUE(CheckMockedApi("CloseFile"));
505 ASSERT_TRUE(CheckMockedStackEmpty());
506 }
507
508 // Test: test-kind=mock, api=BasicBlock::IsCatch, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_IsCatch)509 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_IsCatch)
510 {
511 ASSERT_TRUE(CheckMockedStackEmpty());
512 {
513 abckit::File f(DEFAULT_PATH);
514 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
515 abckit::mock::helpers::GetMockBasicBlock(f).IsCatch();
516 ASSERT_TRUE(CheckMockedApi("BBIsCatch"));
517 }
518 ASSERT_TRUE(CheckMockedApi("CloseFile"));
519 ASSERT_TRUE(CheckMockedStackEmpty());
520 }
521
522 // Test: test-kind=mock, api=BasicBlock::Dump, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_Dump)523 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_Dump)
524 {
525 ASSERT_TRUE(CheckMockedStackEmpty());
526 {
527 abckit::File f(DEFAULT_PATH);
528 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
529 abckit::mock::helpers::GetMockBasicBlock(f).Dump(DEFAULT_I32);
530 ASSERT_TRUE(CheckMockedApi("BBDump"));
531 }
532 ASSERT_TRUE(CheckMockedApi("CloseFile"));
533 ASSERT_TRUE(CheckMockedStackEmpty());
534 }
535
536 // Test: test-kind=mock, api=BasicBlock::SplitBlockAfterInstruction, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_SplitBlockAfterInstruction)537 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_SplitBlockAfterInstruction)
538 {
539 ASSERT_TRUE(CheckMockedStackEmpty());
540 {
541 abckit::File f(DEFAULT_PATH);
542 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
543 abckit::mock::helpers::GetMockBasicBlock(f).SplitBlockAfterInstruction(
544 abckit::mock::helpers::GetMockInstruction(f), DEFAULT_BOOL);
545 ASSERT_TRUE(CheckMockedApi("BBSplitBlockAfterInstruction"));
546 }
547 ASSERT_TRUE(CheckMockedApi("CloseFile"));
548 ASSERT_TRUE(CheckMockedStackEmpty());
549 }
550
551 // Test: test-kind=mock, api=BasicBlock::CreatePhi, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_CreatePhi)552 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_CreatePhi)
553 {
554 ASSERT_TRUE(CheckMockedStackEmpty());
555 {
556 abckit::File f(DEFAULT_PATH);
557 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
558 abckit::mock::helpers::GetMockBasicBlock(f).CreatePhi(abckit::mock::helpers::GetMockInstruction(f),
559 abckit::mock::helpers::GetMockInstruction(f));
560 ASSERT_TRUE(CheckMockedApi("BBCreatePhi"));
561 }
562 ASSERT_TRUE(CheckMockedApi("CloseFile"));
563 ASSERT_TRUE(CheckMockedStackEmpty());
564 }
565
566 // Test: test-kind=mock, api=BasicBlock::CreateCatchPhi, abc-kind=ArkTS1, category=internal, extension=cpp
TEST_F(LibAbcKitCppMockTestBasicBlock,BasicBlock_CreateCatchPhi)567 TEST_F(LibAbcKitCppMockTestBasicBlock, BasicBlock_CreateCatchPhi)
568 {
569 ASSERT_TRUE(CheckMockedStackEmpty());
570 {
571 abckit::File f(DEFAULT_PATH);
572 ASSERT_TRUE(CheckMockedApi("OpenAbc"));
573 abckit::mock::helpers::GetMockBasicBlock(f).CreateCatchPhi(abckit::mock::helpers::GetMockInstruction(f),
574 abckit::mock::helpers::GetMockInstruction(f));
575 ASSERT_TRUE(CheckMockedApi("BBCreateCatchPhi"));
576 }
577 ASSERT_TRUE(CheckMockedApi("CloseFile"));
578 ASSERT_TRUE(CheckMockedStackEmpty());
579 }
580
581 } // namespace libabckit::test