Skip to content

Commit 10acf9d

Browse files
lucic71lucic71
committed
Add switch interleaved with loops tests
1 parent f84dbd4 commit 10acf9d

3 files changed

Lines changed: 374 additions & 0 deletions

File tree

‎tests/unit/out/refcount/switch.rs‎

Lines changed: 147 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -658,6 +658,111 @@ pub fn borrow_in_condition_and_in_body_30(x: i32) -> i32 {
658658
});
659659
panic!("ub: non-void function does not return a value")
660660
}
661+
pub fn for_in_switch_break_31(n: i32) -> i32 {
662+
let n: Value<i32> = Rc::new(RefCell::new(n));
663+
let r: Value<i32> = Rc::new(RefCell::new(0));
664+
'switch: {
665+
let __match_cond = (*n.borrow());
666+
match __match_cond {
667+
v if v == 0 => {
668+
let i: Value<i32> = Rc::new(RefCell::new(0));
669+
'loop_: while ((*i.borrow()) < 10) {
670+
if ((*i.borrow()) == 3) {
671+
break;
672+
}
673+
(*r.borrow_mut()) += (*i.borrow());
674+
(*i.borrow_mut()).prefix_inc();
675+
}
676+
(*r.borrow_mut()) += 100;
677+
break 'switch;
678+
}
679+
_ => {
680+
(*r.borrow_mut()) = -1_i32;
681+
break 'switch;
682+
}
683+
}
684+
};
685+
return (*r.borrow());
686+
}
687+
pub fn for_in_switch_continue_32(n: i32) -> i32 {
688+
let n: Value<i32> = Rc::new(RefCell::new(n));
689+
let r: Value<i32> = Rc::new(RefCell::new(0));
690+
'switch: {
691+
let __match_cond = (*n.borrow());
692+
match __match_cond {
693+
v if v == 0 => {
694+
let i: Value<i32> = Rc::new(RefCell::new(0));
695+
'loop_: while ((*i.borrow()) < 5) {
696+
if (((*i.borrow()) % 2) == 0) {
697+
(*i.borrow_mut()).prefix_inc();
698+
continue 'loop_;
699+
}
700+
(*r.borrow_mut()) += (*i.borrow());
701+
(*i.borrow_mut()).prefix_inc();
702+
}
703+
break 'switch;
704+
}
705+
_ => {
706+
(*r.borrow_mut()) = -1_i32;
707+
break 'switch;
708+
}
709+
}
710+
};
711+
return (*r.borrow());
712+
}
713+
pub fn while_in_switch_break_33(n: i32) -> i32 {
714+
let n: Value<i32> = Rc::new(RefCell::new(n));
715+
let r: Value<i32> = Rc::new(RefCell::new(0));
716+
switch!(match (*n.borrow()) {
717+
v if v == 0 => {
718+
let i: Value<i32> = Rc::new(RefCell::new(0));
719+
'loop_: while ((*i.borrow()) < 10) {
720+
if ((*i.borrow()) == 4) {
721+
break;
722+
}
723+
(*r.borrow_mut()) += (*i.borrow());
724+
(*i.borrow_mut()).prefix_inc();
725+
}
726+
(*r.borrow_mut()) += 1000;
727+
break;
728+
}
729+
_ => {
730+
(*r.borrow_mut()) = -1_i32;
731+
break;
732+
}
733+
});
734+
return (*r.borrow());
735+
}
736+
pub fn for_switch_for_break_34(n: i32) -> i32 {
737+
let n: Value<i32> = Rc::new(RefCell::new(n));
738+
let r: Value<i32> = Rc::new(RefCell::new(0));
739+
let i: Value<i32> = Rc::new(RefCell::new(0));
740+
'loop_: while ((*i.borrow()) < (*n.borrow())) {
741+
'switch: {
742+
let __match_cond = (*i.borrow());
743+
match __match_cond {
744+
v if v == 1 => {
745+
let j: Value<i32> = Rc::new(RefCell::new(0));
746+
'loop_: while ((*j.borrow()) < 10) {
747+
if ((*j.borrow()) == 2) {
748+
break;
749+
}
750+
(*r.borrow_mut()) += 1;
751+
(*j.borrow_mut()).prefix_inc();
752+
}
753+
(*r.borrow_mut()) += 100;
754+
break 'switch;
755+
}
756+
_ => {
757+
(*r.borrow_mut()) += 10;
758+
break 'switch;
759+
}
760+
}
761+
};
762+
(*i.borrow_mut()).prefix_inc();
763+
}
764+
return (*r.borrow());
765+
}
661766
pub fn main() {
662767
std::process::exit(main_0());
663768
}
@@ -1217,5 +1322,47 @@ fn main_0() -> i32 {
12171322
borrow_in_condition_and_in_body_30(_x)
12181323
}) == 2)
12191324
);
1325+
assert!(
1326+
(({
1327+
let _n: i32 = 0;
1328+
for_in_switch_break_31(_n)
1329+
}) == 103)
1330+
);
1331+
assert!(
1332+
(({
1333+
let _n: i32 = 99;
1334+
for_in_switch_break_31(_n)
1335+
}) == -1_i32)
1336+
);
1337+
assert!(
1338+
(({
1339+
let _n: i32 = 0;
1340+
for_in_switch_continue_32(_n)
1341+
}) == 4)
1342+
);
1343+
assert!(
1344+
(({
1345+
let _n: i32 = 99;
1346+
for_in_switch_continue_32(_n)
1347+
}) == -1_i32)
1348+
);
1349+
assert!(
1350+
(({
1351+
let _n: i32 = 0;
1352+
while_in_switch_break_33(_n)
1353+
}) == 1006)
1354+
);
1355+
assert!(
1356+
(({
1357+
let _n: i32 = 99;
1358+
while_in_switch_break_33(_n)
1359+
}) == -1_i32)
1360+
);
1361+
assert!(
1362+
(({
1363+
let _n: i32 = 3;
1364+
for_switch_for_break_34(_n)
1365+
}) == 122)
1366+
);
12201367
return 0;
12211368
}

‎tests/unit/out/unsafe/switch.rs‎

Lines changed: 143 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -620,6 +620,107 @@ pub unsafe fn borrow_in_condition_and_in_body_30(mut x: i32) -> i32 {
620620
});
621621
panic!("ub: non-void function does not return a value")
622622
}
623+
pub unsafe fn for_in_switch_break_31(mut n: i32) -> i32 {
624+
let mut r: i32 = 0;
625+
'switch: {
626+
let __match_cond = n;
627+
match __match_cond {
628+
v if v == 0 => {
629+
let mut i: i32 = 0;
630+
'loop_: while ((i) < (10)) {
631+
if ((i) == (3)) {
632+
break;
633+
}
634+
r += i;
635+
i.prefix_inc();
636+
}
637+
r += 100;
638+
break 'switch;
639+
}
640+
_ => {
641+
r = -1_i32;
642+
break 'switch;
643+
}
644+
}
645+
};
646+
return r;
647+
}
648+
pub unsafe fn for_in_switch_continue_32(mut n: i32) -> i32 {
649+
let mut r: i32 = 0;
650+
'switch: {
651+
let __match_cond = n;
652+
match __match_cond {
653+
v if v == 0 => {
654+
let mut i: i32 = 0;
655+
'loop_: while ((i) < (5)) {
656+
if (((i) % (2)) == (0)) {
657+
i.prefix_inc();
658+
continue 'loop_;
659+
}
660+
r += i;
661+
i.prefix_inc();
662+
}
663+
break 'switch;
664+
}
665+
_ => {
666+
r = -1_i32;
667+
break 'switch;
668+
}
669+
}
670+
};
671+
return r;
672+
}
673+
pub unsafe fn while_in_switch_break_33(mut n: i32) -> i32 {
674+
let mut r: i32 = 0;
675+
switch!(match n {
676+
v if v == 0 => {
677+
let mut i: i32 = 0;
678+
'loop_: while ((i) < (10)) {
679+
if ((i) == (4)) {
680+
break;
681+
}
682+
r += i;
683+
i.prefix_inc();
684+
}
685+
r += 1000;
686+
break;
687+
}
688+
_ => {
689+
r = -1_i32;
690+
break;
691+
}
692+
});
693+
return r;
694+
}
695+
pub unsafe fn for_switch_for_break_34(mut n: i32) -> i32 {
696+
let mut r: i32 = 0;
697+
let mut i: i32 = 0;
698+
'loop_: while ((i) < (n)) {
699+
'switch: {
700+
let __match_cond = i;
701+
match __match_cond {
702+
v if v == 1 => {
703+
let mut j: i32 = 0;
704+
'loop_: while ((j) < (10)) {
705+
if ((j) == (2)) {
706+
break;
707+
}
708+
r += 1;
709+
j.prefix_inc();
710+
}
711+
r += 100;
712+
break 'switch;
713+
}
714+
_ => {
715+
r += 10;
716+
break 'switch;
717+
}
718+
}
719+
};
720+
i.prefix_inc();
721+
}
722+
return r;
723+
}
623724
pub fn main() {
624725
unsafe {
625726
std::process::exit(main_0() as i32);
@@ -1181,5 +1282,47 @@ unsafe fn main_0() -> i32 {
11811282
borrow_in_condition_and_in_body_30(_x)
11821283
}) == (2))
11831284
);
1285+
assert!(
1286+
((unsafe {
1287+
let _n: i32 = 0;
1288+
for_in_switch_break_31(_n)
1289+
}) == (103))
1290+
);
1291+
assert!(
1292+
((unsafe {
1293+
let _n: i32 = 99;
1294+
for_in_switch_break_31(_n)
1295+
}) == (-1_i32))
1296+
);
1297+
assert!(
1298+
((unsafe {
1299+
let _n: i32 = 0;
1300+
for_in_switch_continue_32(_n)
1301+
}) == (4))
1302+
);
1303+
assert!(
1304+
((unsafe {
1305+
let _n: i32 = 99;
1306+
for_in_switch_continue_32(_n)
1307+
}) == (-1_i32))
1308+
);
1309+
assert!(
1310+
((unsafe {
1311+
let _n: i32 = 0;
1312+
while_in_switch_break_33(_n)
1313+
}) == (1006))
1314+
);
1315+
assert!(
1316+
((unsafe {
1317+
let _n: i32 = 99;
1318+
while_in_switch_break_33(_n)
1319+
}) == (-1_i32))
1320+
);
1321+
assert!(
1322+
((unsafe {
1323+
let _n: i32 = 3;
1324+
for_switch_for_break_34(_n)
1325+
}) == (122))
1326+
);
11841327
return 0;
11851328
}

0 commit comments

Comments
 (0)