From 9d4741b5eaa7e91c1b9d9133dc7ead1d892fa962 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Fri, 15 May 2026 11:30:10 +0100 Subject: [PATCH 1/2] Add doubly linked list test --- tests/unit/doubly_linked_list.cpp | 102 +++++ tests/unit/out/refcount/doubly_linked_list.rs | 359 ++++++++++++++++++ tests/unit/out/unsafe/doubly_linked_list.rs | 290 ++++++++++++++ 3 files changed, 751 insertions(+) create mode 100644 tests/unit/doubly_linked_list.cpp create mode 100644 tests/unit/out/refcount/doubly_linked_list.rs create mode 100644 tests/unit/out/unsafe/doubly_linked_list.rs diff --git a/tests/unit/doubly_linked_list.cpp b/tests/unit/doubly_linked_list.cpp new file mode 100644 index 00000000..5b9b6cbf --- /dev/null +++ b/tests/unit/doubly_linked_list.cpp @@ -0,0 +1,102 @@ +#include + +struct Node { + int val; + Node *next; + Node *prev; + + void SetNext(Node *n) { this->next = n; } + void SetPrev(Node *p) { this->prev = p; } +}; + +Node *Find(Node *head, int idx) { + Node *curr = head; + for (int i = 0; i < idx; i++) { + curr = curr->next; + } + return curr; +} + +Node *FindBack(Node *tail, int idx) { + Node *curr = tail; + for (int i = 0; i < idx; i++) { + curr = curr->prev; + } + return curr; +} + +void Append(Node &head, Node &new_node) { + Node *curr = &head; + while (curr->next != nullptr) { + curr = curr->next; + } + curr->SetNext(&new_node); + new_node.SetPrev(curr); +} + +Node *Delete(Node *head, int val) { + Node *curr = head; + while (curr != nullptr) { + if (curr->val == val) { + Node *prev = curr->prev; + Node *next = curr->next; + if (prev != nullptr) { + prev->next = next; + } + if (next != nullptr) { + next->prev = prev; + } + if (prev != nullptr) { + return head; + } else { + return next; + } + } + curr = curr->next; + } + return head; +} + +Node *Tail(Node *head) { + Node *curr = head; + while (curr->next != nullptr) { + curr = curr->next; + } + return curr; +} + +int main() { + Node n0 = {5, nullptr, nullptr}; + Node *head = &n0; + Node n1 = {4, nullptr, nullptr}; + Node n2 = {3, nullptr, nullptr}; + Node n3 = {2, nullptr, nullptr}; + Node n4 = {1, nullptr, nullptr}; + Node n5 = {0, nullptr, nullptr}; + Node n6 = {-1, nullptr, nullptr}; + Node n7 = {-2, nullptr, nullptr}; + Append(*head, n1); + Append(*head, n2); + Append(*head, n3); + Append(*head, n4); + Append(*head, n5); + Append(*head, n6); + Append(*head, n7); + head = Delete(head, 5); + head = Delete(head, 0); + head = Delete(head, -2); + Node *tail = Tail(head); + assert(Find(head, 0)->val == 4); + assert(Find(head, 1)->val == 3); + assert(Find(head, 2)->val == 2); + assert(Find(head, 3)->val == 1); + assert(Find(head, 4)->val == -1); + assert(Find(head, 5) == nullptr); + assert(FindBack(tail, 0)->val == -1); + assert(FindBack(tail, 1)->val == 1); + assert(FindBack(tail, 2)->val == 2); + assert(FindBack(tail, 3)->val == 3); + assert(FindBack(tail, 4)->val == 4); + assert(FindBack(tail, 4)->prev == nullptr); + return 0; +} diff --git a/tests/unit/out/refcount/doubly_linked_list.rs b/tests/unit/out/refcount/doubly_linked_list.rs new file mode 100644 index 00000000..7ca523c1 --- /dev/null +++ b/tests/unit/out/refcount/doubly_linked_list.rs @@ -0,0 +1,359 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Default)] +pub struct Node { + pub val: Value, + pub next: Value>, + pub prev: Value>, +} +impl Node { + pub fn SetNext(&self, n: Ptr) { + let n: Value> = Rc::new(RefCell::new(n)); + (*self.next.borrow_mut()) = (*n.borrow()).clone(); + } + pub fn SetPrev(&self, p: Ptr) { + let p: Value> = Rc::new(RefCell::new(p)); + (*self.prev.borrow_mut()) = (*p.borrow()).clone(); + } +} +impl Clone for Node { + fn clone(&self) -> Self { + let mut this = Self { + val: Rc::new(RefCell::new((*self.val.borrow()))), + next: Rc::new(RefCell::new((*self.next.borrow()).clone())), + prev: Rc::new(RefCell::new((*self.prev.borrow()).clone())), + }; + this + } +} +impl ByteRepr for Node {} +pub fn Find_0(head: Ptr, idx: i32) -> Ptr { + let head: Value> = Rc::new(RefCell::new(head)); + let idx: Value = Rc::new(RefCell::new(idx)); + let curr: Value> = Rc::new(RefCell::new((*head.borrow()).clone())); + let i: Value = Rc::new(RefCell::new(0)); + 'loop_: while ((*i.borrow()) < (*idx.borrow())) { + let __rhs = (*(*(*curr.borrow()).upgrade().deref()).next.borrow()).clone(); + (*curr.borrow_mut()) = __rhs; + (*i.borrow_mut()).postfix_inc(); + } + return (*curr.borrow()).clone(); +} +pub fn FindBack_1(tail: Ptr, idx: i32) -> Ptr { + let tail: Value> = Rc::new(RefCell::new(tail)); + let idx: Value = Rc::new(RefCell::new(idx)); + let curr: Value> = Rc::new(RefCell::new((*tail.borrow()).clone())); + let i: Value = Rc::new(RefCell::new(0)); + 'loop_: while ((*i.borrow()) < (*idx.borrow())) { + let __rhs = (*(*(*curr.borrow()).upgrade().deref()).prev.borrow()).clone(); + (*curr.borrow_mut()) = __rhs; + (*i.borrow_mut()).postfix_inc(); + } + return (*curr.borrow()).clone(); +} +pub fn Append_2(head: Ptr, new_node: Ptr) { + let curr: Value> = Rc::new(RefCell::new((head).clone())); + 'loop_: while !((*(*(*curr.borrow()).upgrade().deref()).next.borrow()).is_null()) { + let __rhs = (*(*(*curr.borrow()).upgrade().deref()).next.borrow()).clone(); + (*curr.borrow_mut()) = __rhs; + } + ({ + let _n: Ptr = (new_node).clone(); + (*(*curr.borrow()).upgrade().deref()).SetNext(_n) + }); + ({ + let _p: Ptr = (*curr.borrow()).clone(); + (*new_node.upgrade().deref()).SetPrev(_p) + }); +} +pub fn Delete_3(head: Ptr, val: i32) -> Ptr { + let head: Value> = Rc::new(RefCell::new(head)); + let val: Value = Rc::new(RefCell::new(val)); + let curr: Value> = Rc::new(RefCell::new((*head.borrow()).clone())); + 'loop_: while !((*curr.borrow()).is_null()) { + if { + let _lhs = (*(*(*curr.borrow()).upgrade().deref()).val.borrow()); + _lhs == (*val.borrow()) + } { + let prev: Value> = Rc::new(RefCell::new( + (*(*(*curr.borrow()).upgrade().deref()).prev.borrow()).clone(), + )); + let next: Value> = Rc::new(RefCell::new( + (*(*(*curr.borrow()).upgrade().deref()).next.borrow()).clone(), + )); + if !((*prev.borrow()).is_null()) { + (*(*(*prev.borrow()).upgrade().deref()).next.borrow_mut()) = + (*next.borrow()).clone(); + } + if !((*next.borrow()).is_null()) { + (*(*(*next.borrow()).upgrade().deref()).prev.borrow_mut()) = + (*prev.borrow()).clone(); + } + if !((*prev.borrow()).is_null()) { + return (*head.borrow()).clone(); + } else { + return (*next.borrow()).clone(); + } + } + let __rhs = (*(*(*curr.borrow()).upgrade().deref()).next.borrow()).clone(); + (*curr.borrow_mut()) = __rhs; + } + return (*head.borrow()).clone(); +} +pub fn Tail_4(head: Ptr) -> Ptr { + let head: Value> = Rc::new(RefCell::new(head)); + let curr: Value> = Rc::new(RefCell::new((*head.borrow()).clone())); + 'loop_: while !((*(*(*curr.borrow()).upgrade().deref()).next.borrow()).is_null()) { + let __rhs = (*(*(*curr.borrow()).upgrade().deref()).next.borrow()).clone(); + (*curr.borrow_mut()) = __rhs; + } + return (*curr.borrow()).clone(); +} +pub fn main() { + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let n0: Value = Rc::new(RefCell::new(Node { + val: Rc::new(RefCell::new(5)), + next: Rc::new(RefCell::new(Ptr::::null())), + prev: Rc::new(RefCell::new(Ptr::::null())), + })); + let head: Value> = Rc::new(RefCell::new((n0.as_pointer()))); + let n1: Value = Rc::new(RefCell::new(Node { + val: Rc::new(RefCell::new(4)), + next: Rc::new(RefCell::new(Ptr::::null())), + prev: Rc::new(RefCell::new(Ptr::::null())), + })); + let n2: Value = Rc::new(RefCell::new(Node { + val: Rc::new(RefCell::new(3)), + next: Rc::new(RefCell::new(Ptr::::null())), + prev: Rc::new(RefCell::new(Ptr::::null())), + })); + let n3: Value = Rc::new(RefCell::new(Node { + val: Rc::new(RefCell::new(2)), + next: Rc::new(RefCell::new(Ptr::::null())), + prev: Rc::new(RefCell::new(Ptr::::null())), + })); + let n4: Value = Rc::new(RefCell::new(Node { + val: Rc::new(RefCell::new(1)), + next: Rc::new(RefCell::new(Ptr::::null())), + prev: Rc::new(RefCell::new(Ptr::::null())), + })); + let n5: Value = Rc::new(RefCell::new(Node { + val: Rc::new(RefCell::new(0)), + next: Rc::new(RefCell::new(Ptr::::null())), + prev: Rc::new(RefCell::new(Ptr::::null())), + })); + let n6: Value = Rc::new(RefCell::new(Node { + val: Rc::new(RefCell::new(-1_i32)), + next: Rc::new(RefCell::new(Ptr::::null())), + prev: Rc::new(RefCell::new(Ptr::::null())), + })); + let n7: Value = Rc::new(RefCell::new(Node { + val: Rc::new(RefCell::new(-2_i32)), + next: Rc::new(RefCell::new(Ptr::::null())), + prev: Rc::new(RefCell::new(Ptr::::null())), + })); + ({ + let _head: Ptr = (*head.borrow()).clone(); + let _new_node: Ptr = n1.as_pointer(); + Append_2(_head, _new_node) + }); + ({ + let _head: Ptr = (*head.borrow()).clone(); + let _new_node: Ptr = n2.as_pointer(); + Append_2(_head, _new_node) + }); + ({ + let _head: Ptr = (*head.borrow()).clone(); + let _new_node: Ptr = n3.as_pointer(); + Append_2(_head, _new_node) + }); + ({ + let _head: Ptr = (*head.borrow()).clone(); + let _new_node: Ptr = n4.as_pointer(); + Append_2(_head, _new_node) + }); + ({ + let _head: Ptr = (*head.borrow()).clone(); + let _new_node: Ptr = n5.as_pointer(); + Append_2(_head, _new_node) + }); + ({ + let _head: Ptr = (*head.borrow()).clone(); + let _new_node: Ptr = n6.as_pointer(); + Append_2(_head, _new_node) + }); + ({ + let _head: Ptr = (*head.borrow()).clone(); + let _new_node: Ptr = n7.as_pointer(); + Append_2(_head, _new_node) + }); + let __rhs = ({ + let _head: Ptr = (*head.borrow()).clone(); + let _val: i32 = 5; + Delete_3(_head, _val) + }); + (*head.borrow_mut()) = __rhs; + let __rhs = ({ + let _head: Ptr = (*head.borrow()).clone(); + let _val: i32 = 0; + Delete_3(_head, _val) + }); + (*head.borrow_mut()) = __rhs; + let __rhs = ({ + let _head: Ptr = (*head.borrow()).clone(); + let _val: i32 = -2_i32; + Delete_3(_head, _val) + }); + (*head.borrow_mut()) = __rhs; + let tail: Value> = Rc::new(RefCell::new( + ({ + let _head: Ptr = (*head.borrow()).clone(); + Tail_4(_head) + }), + )); + assert!( + ((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 0; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 4) + ); + assert!( + ((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 1; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 3) + ); + assert!( + ((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 2; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 2) + ); + assert!( + ((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 3; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 1) + ); + assert!( + ((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 4; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == -1_i32) + ); + assert!(({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 5; + Find_0(_head, _idx) + }) + .is_null()); + assert!( + ((*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 0; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == -1_i32) + ); + assert!( + ((*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 1; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 1) + ); + assert!( + ((*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 2; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 2) + ); + assert!( + ((*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 3; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 3) + ); + assert!( + ((*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 4; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 4) + ); + assert!((*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 4; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .prev + .borrow()) + .is_null()); + return 0; +} diff --git a/tests/unit/out/unsafe/doubly_linked_list.rs b/tests/unit/out/unsafe/doubly_linked_list.rs new file mode 100644 index 00000000..3cbe38fe --- /dev/null +++ b/tests/unit/out/unsafe/doubly_linked_list.rs @@ -0,0 +1,290 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, Default)] +pub struct Node { + pub val: i32, + pub next: *mut Node, + pub prev: *mut Node, +} +impl Node { + pub unsafe fn SetNext(&mut self, mut n: *mut Node) { + self.next = n; + } + pub unsafe fn SetPrev(&mut self, mut p: *mut Node) { + self.prev = p; + } +} +pub unsafe fn Find_0(mut head: *mut Node, mut idx: i32) -> *mut Node { + let mut curr: *mut Node = head; + let mut i: i32 = 0; + 'loop_: while ((i) < (idx)) { + curr = (*curr).next; + i.postfix_inc(); + } + return curr; +} +pub unsafe fn FindBack_1(mut tail: *mut Node, mut idx: i32) -> *mut Node { + let mut curr: *mut Node = tail; + let mut i: i32 = 0; + 'loop_: while ((i) < (idx)) { + curr = (*curr).prev; + i.postfix_inc(); + } + return curr; +} +pub unsafe fn Append_2(head: *mut Node, new_node: *mut Node) { + let mut curr: *mut Node = (head); + 'loop_: while !(((*curr).next).is_null()) { + curr = (*curr).next; + } + (unsafe { + let _n: *mut Node = (new_node); + (*curr).SetNext(_n) + }); + (unsafe { + let _p: *mut Node = curr; + (*new_node).SetPrev(_p) + }); +} +pub unsafe fn Delete_3(mut head: *mut Node, mut val: i32) -> *mut Node { + let mut curr: *mut Node = head; + 'loop_: while !((curr).is_null()) { + if (((*curr).val) == (val)) { + let mut prev: *mut Node = (*curr).prev; + let mut next: *mut Node = (*curr).next; + if !((prev).is_null()) { + (*prev).next = next; + } + if !((next).is_null()) { + (*next).prev = prev; + } + if !((prev).is_null()) { + return head; + } else { + return next; + } + } + curr = (*curr).next; + } + return head; +} +pub unsafe fn Tail_4(mut head: *mut Node) -> *mut Node { + let mut curr: *mut Node = head; + 'loop_: while !(((*curr).next).is_null()) { + curr = (*curr).next; + } + return curr; +} +pub fn main() { + unsafe { + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut n0: Node = Node { + val: 5, + next: std::ptr::null_mut(), + prev: std::ptr::null_mut(), + }; + let mut head: *mut Node = (&mut n0 as *mut Node); + let mut n1: Node = Node { + val: 4, + next: std::ptr::null_mut(), + prev: std::ptr::null_mut(), + }; + let mut n2: Node = Node { + val: 3, + next: std::ptr::null_mut(), + prev: std::ptr::null_mut(), + }; + let mut n3: Node = Node { + val: 2, + next: std::ptr::null_mut(), + prev: std::ptr::null_mut(), + }; + let mut n4: Node = Node { + val: 1, + next: std::ptr::null_mut(), + prev: std::ptr::null_mut(), + }; + let mut n5: Node = Node { + val: 0, + next: std::ptr::null_mut(), + prev: std::ptr::null_mut(), + }; + let mut n6: Node = Node { + val: -1_i32, + next: std::ptr::null_mut(), + prev: std::ptr::null_mut(), + }; + let mut n7: Node = Node { + val: -2_i32, + next: std::ptr::null_mut(), + prev: std::ptr::null_mut(), + }; + (unsafe { + let _head: *mut Node = &mut (*head) as *mut Node; + let _new_node: *mut Node = &mut n1 as *mut Node; + Append_2(_head, _new_node) + }); + (unsafe { + let _head: *mut Node = &mut (*head) as *mut Node; + let _new_node: *mut Node = &mut n2 as *mut Node; + Append_2(_head, _new_node) + }); + (unsafe { + let _head: *mut Node = &mut (*head) as *mut Node; + let _new_node: *mut Node = &mut n3 as *mut Node; + Append_2(_head, _new_node) + }); + (unsafe { + let _head: *mut Node = &mut (*head) as *mut Node; + let _new_node: *mut Node = &mut n4 as *mut Node; + Append_2(_head, _new_node) + }); + (unsafe { + let _head: *mut Node = &mut (*head) as *mut Node; + let _new_node: *mut Node = &mut n5 as *mut Node; + Append_2(_head, _new_node) + }); + (unsafe { + let _head: *mut Node = &mut (*head) as *mut Node; + let _new_node: *mut Node = &mut n6 as *mut Node; + Append_2(_head, _new_node) + }); + (unsafe { + let _head: *mut Node = &mut (*head) as *mut Node; + let _new_node: *mut Node = &mut n7 as *mut Node; + Append_2(_head, _new_node) + }); + head = (unsafe { + let _head: *mut Node = head; + let _val: i32 = 5; + Delete_3(_head, _val) + }); + head = (unsafe { + let _head: *mut Node = head; + let _val: i32 = 0; + Delete_3(_head, _val) + }); + head = (unsafe { + let _head: *mut Node = head; + let _val: i32 = -2_i32; + Delete_3(_head, _val) + }); + let mut tail: *mut Node = (unsafe { + let _head: *mut Node = head; + Tail_4(_head) + }); + assert!( + (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 0; + Find_0(_head, _idx) + })) + .val) + == (4)) + ); + assert!( + (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 1; + Find_0(_head, _idx) + })) + .val) + == (3)) + ); + assert!( + (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 2; + Find_0(_head, _idx) + })) + .val) + == (2)) + ); + assert!( + (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 3; + Find_0(_head, _idx) + })) + .val) + == (1)) + ); + assert!( + (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 4; + Find_0(_head, _idx) + })) + .val) + == (-1_i32)) + ); + assert!((unsafe { + let _head: *mut Node = head; + let _idx: i32 = 5; + Find_0(_head, _idx) + }) + .is_null()); + assert!( + (((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 0; + FindBack_1(_tail, _idx) + })) + .val) + == (-1_i32)) + ); + assert!( + (((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 1; + FindBack_1(_tail, _idx) + })) + .val) + == (1)) + ); + assert!( + (((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 2; + FindBack_1(_tail, _idx) + })) + .val) + == (2)) + ); + assert!( + (((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 3; + FindBack_1(_tail, _idx) + })) + .val) + == (3)) + ); + assert!( + (((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 4; + FindBack_1(_tail, _idx) + })) + .val) + == (4)) + ); + assert!(((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 4; + FindBack_1(_tail, _idx) + })) + .prev) + .is_null()); + return 0; +} From 7aaef6a67b12e115bf84233ca7afb806ccdbc501 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Fri, 15 May 2026 11:43:31 +0100 Subject: [PATCH 2/2] Access the node pointers multiple time in the same expr --- tests/unit/doubly_linked_list.cpp | 21 ++ tests/unit/out/refcount/doubly_linked_list.rs | 266 ++++++++++++++++++ tests/unit/out/unsafe/doubly_linked_list.rs | 167 +++++++++++ 3 files changed, 454 insertions(+) diff --git a/tests/unit/doubly_linked_list.cpp b/tests/unit/doubly_linked_list.cpp index 5b9b6cbf..817d6a04 100644 --- a/tests/unit/doubly_linked_list.cpp +++ b/tests/unit/doubly_linked_list.cpp @@ -86,6 +86,7 @@ int main() { head = Delete(head, 0); head = Delete(head, -2); Node *tail = Tail(head); + assert(Find(head, 0)->val == 4); assert(Find(head, 1)->val == 3); assert(Find(head, 2)->val == 2); @@ -98,5 +99,25 @@ int main() { assert(FindBack(tail, 3)->val == 3); assert(FindBack(tail, 4)->val == 4); assert(FindBack(tail, 4)->prev == nullptr); + + assert(Find(head, 0)->next->val == 3); + assert(Find(head, 1)->next->next->val == 1); + assert(Find(head, 2)->prev->val == 3); + assert(Find(head, 4)->next == nullptr); + assert(FindBack(tail, 1)->prev->prev->val == 3); + + Find(head, 0)->next->val = 30; + assert(Find(head, 1)->val == 30); + Find(head, 1)->next->val = Find(head, 0)->val + Find(head, 3)->val; + assert(Find(head, 2)->val == 4 + 1); + + int sum = Find(head, 0)->val + Find(head, 1)->val + Find(head, 2)->val + + Find(head, 3)->val + Find(head, 4)->val; + assert(sum == 4 + 30 + 5 + 1 + -1); + + assert(Find(head, 0)->val + FindBack(tail, 0)->val == 4 + -1); + assert(Find(head, 2)->next->val == FindBack(tail, 1)->val); + assert(Find(head, 0)->prev == FindBack(tail, 4)->prev); + return 0; } diff --git a/tests/unit/out/refcount/doubly_linked_list.rs b/tests/unit/out/refcount/doubly_linked_list.rs index 7ca523c1..bd8e68b3 100644 --- a/tests/unit/out/refcount/doubly_linked_list.rs +++ b/tests/unit/out/refcount/doubly_linked_list.rs @@ -355,5 +355,271 @@ fn main_0() -> i32 { .prev .borrow()) .is_null()); + assert!( + ((*(*(*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 0; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .next + .borrow()) + .upgrade() + .deref()) + .val + .borrow()) + == 3) + ); + assert!( + ((*(*(*(*(*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 1; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .next + .borrow()) + .upgrade() + .deref()) + .next + .borrow()) + .upgrade() + .deref()) + .val + .borrow()) + == 1) + ); + assert!( + ((*(*(*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 2; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .prev + .borrow()) + .upgrade() + .deref()) + .val + .borrow()) + == 3) + ); + assert!((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 4; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .next + .borrow()) + .is_null()); + assert!( + ((*(*(*(*(*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 1; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .prev + .borrow()) + .upgrade() + .deref()) + .prev + .borrow()) + .upgrade() + .deref()) + .val + .borrow()) + == 3) + ); + (*(*(*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 0; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .next + .borrow()) + .upgrade() + .deref()) + .val + .borrow_mut()) = 30; + assert!( + ((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 1; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == 30) + ); + let __rhs = ((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 0; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + + (*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 3; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow())); + (*(*(*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 1; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .next + .borrow()) + .upgrade() + .deref()) + .val + .borrow_mut()) = __rhs; + assert!( + ((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 2; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + == (4 + 1)) + ); + let sum: Value = Rc::new(RefCell::new( + (((((*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 0; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + + (*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 1; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow())) + + (*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 2; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow())) + + (*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 3; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow())) + + (*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 4; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow())), + )); + assert!(((*sum.borrow()) == ((((4 + 30) + 5) + 1) + -1_i32))); + assert!( + ({ + let _lhs = (*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 0; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()); + _lhs + (*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 0; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + } == (4 + -1_i32)) + ); + assert!({ + let _lhs = (*(*(*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 2; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .next + .borrow()) + .upgrade() + .deref()) + .val + .borrow()); + _lhs == (*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 1; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .val + .borrow()) + }); + assert!({ + let _lhs = (*(*({ + let _head: Ptr = (*head.borrow()).clone(); + let _idx: i32 = 0; + Find_0(_head, _idx) + }) + .upgrade() + .deref()) + .prev + .borrow()) + .clone(); + _lhs == (*(*({ + let _tail: Ptr = (*tail.borrow()).clone(); + let _idx: i32 = 4; + FindBack_1(_tail, _idx) + }) + .upgrade() + .deref()) + .prev + .borrow()) + .clone() + }); return 0; } diff --git a/tests/unit/out/unsafe/doubly_linked_list.rs b/tests/unit/out/unsafe/doubly_linked_list.rs index 3cbe38fe..a6ef48c2 100644 --- a/tests/unit/out/unsafe/doubly_linked_list.rs +++ b/tests/unit/out/unsafe/doubly_linked_list.rs @@ -286,5 +286,172 @@ unsafe fn main_0() -> i32 { })) .prev) .is_null()); + assert!( + (((*(*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 0; + Find_0(_head, _idx) + })) + .next) + .val) + == (3)) + ); + assert!( + (((*(*(*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 1; + Find_0(_head, _idx) + })) + .next) + .next) + .val) + == (1)) + ); + assert!( + (((*(*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 2; + Find_0(_head, _idx) + })) + .prev) + .val) + == (3)) + ); + assert!(((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 4; + Find_0(_head, _idx) + })) + .next) + .is_null()); + assert!( + (((*(*(*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 1; + FindBack_1(_tail, _idx) + })) + .prev) + .prev) + .val) + == (3)) + ); + (*(*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 0; + Find_0(_head, _idx) + })) + .next) + .val = 30; + assert!( + (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 1; + Find_0(_head, _idx) + })) + .val) + == (30)) + ); + (*(*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 1; + Find_0(_head, _idx) + })) + .next) + .val = (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 0; + Find_0(_head, _idx) + })) + .val) + + ((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 3; + Find_0(_head, _idx) + })) + .val)); + assert!( + (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 2; + Find_0(_head, _idx) + })) + .val) + == ((4) + (1))) + ); + let mut sum: i32 = ((((((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 0; + Find_0(_head, _idx) + })) + .val) + + ((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 1; + Find_0(_head, _idx) + })) + .val)) + + ((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 2; + Find_0(_head, _idx) + })) + .val)) + + ((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 3; + Find_0(_head, _idx) + })) + .val)) + + ((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 4; + Find_0(_head, _idx) + })) + .val)); + assert!(((sum) == (((((4) + (30)) + (5)) + (1)) + (-1_i32)))); + assert!( + ((((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 0; + Find_0(_head, _idx) + })) + .val) + + ((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 0; + FindBack_1(_tail, _idx) + })) + .val)) + == ((4) + (-1_i32))) + ); + assert!( + (((*(*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 2; + Find_0(_head, _idx) + })) + .next) + .val) + == ((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 1; + FindBack_1(_tail, _idx) + })) + .val)) + ); + assert!( + (((*(unsafe { + let _head: *mut Node = head; + let _idx: i32 = 0; + Find_0(_head, _idx) + })) + .prev) + == ((*(unsafe { + let _tail: *mut Node = tail; + let _idx: i32 = 4; + FindBack_1(_tail, _idx) + })) + .prev)) + ); return 0; }