Update tests

Author: lucic71

tests/unit/out/refcount/string_literals.rs

@@ -6,7 +6,10 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-pub fn foo_0(str: Ptr<u8>) {
+pub fn foo_mut_0(str: Ptr<u8>) {
+    let str: Value<Ptr<u8>> = Rc::new(RefCell::new(str));
+}
+pub fn foo_const_1(str: Ptr<u8>) {
     let str: Value<Ptr<u8>> = Rc::new(RefCell::new(str));
 }
 pub fn main() {
@@ -25,13 +28,41 @@ fn main_0() -> i32 {
     ])));
     let mutable_string: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("hello")));
     let immutable_string: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("hello")));
+    let mutable_string_arr: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
+    let immutable_string_arr: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
+    ({
+        let _str: Ptr<u8> = Ptr::from_string_literal("world");
+        foo_mut_0(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (*mutable_string.borrow()).clone();
+        foo_mut_0(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (mutable_string_arr.as_pointer() as Ptr<u8>);
+        foo_mut_0(_str)
+    });
     ({
         let _str: Ptr<u8> = Ptr::from_string_literal("world");
-        foo_0(_str)
+        foo_const_1(_str)
     });
     ({
         let _str: Ptr<u8> = (*mutable_string.borrow()).clone();
-        foo_0(_str)
+        foo_const_1(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (*immutable_string.borrow()).clone();
+        foo_const_1(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (mutable_string_arr.as_pointer() as Ptr<u8>);
+        foo_const_1(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (immutable_string_arr.as_pointer() as Ptr<u8>);
+        foo_const_1(_str)
     });
     return 0;
 }

tests/unit/out/refcount/string_literals_c.rs

@@ -6,7 +6,10 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-pub fn foo_0(str: Ptr<u8>) {
+pub fn foo_mut_0(str: Ptr<u8>) {
+    let str: Value<Ptr<u8>> = Rc::new(RefCell::new(str));
+}
+pub fn foo_const_1(str: Ptr<u8>) {
     let str: Value<Ptr<u8>> = Rc::new(RefCell::new(str));
 }
 pub fn main() {
@@ -25,13 +28,41 @@ fn main_0() -> i32 {
     ])));
     let mutable_string: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("hello")));
     let immutable_string: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("hello")));
+    let mutable_string_arr: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
+    let immutable_string_arr: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
+    ({
+        let _str: Ptr<u8> = Ptr::from_string_literal("world");
+        foo_mut_0(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (*mutable_string.borrow()).clone();
+        foo_mut_0(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (mutable_string_arr.as_pointer() as Ptr<u8>);
+        foo_mut_0(_str)
+    });
     ({
         let _str: Ptr<u8> = Ptr::from_string_literal("world");
-        foo_0(_str)
+        foo_const_1(_str)
     });
     ({
         let _str: Ptr<u8> = (*mutable_string.borrow()).clone();
-        foo_0(_str)
+        foo_const_1(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (*immutable_string.borrow()).clone();
+        foo_const_1(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (mutable_string_arr.as_pointer() as Ptr<u8>);
+        foo_const_1(_str)
+    });
+    ({
+        let _str: Ptr<u8> = (immutable_string_arr.as_pointer() as Ptr<u8>);
+        foo_const_1(_str)
     });
     return 0;
 }

tests/unit/out/unsafe/borrow_mut_opt.rs

@@ -23,7 +23,7 @@ pub unsafe fn convert_without_rhs_0() {
     let mut w: i32 = ((arr[(y) as usize]) + (arr[(x) as usize]));
     w += (((z) + (y)) + (x));
     let mut arr2: [u8; 3] = [('a' as u8), ('b' as u8), ('c' as u8)];
-    let mut p1: *const i32 = (&mut x as *mut i32);
+    let mut p1: *const i32 = (&mut x as *mut i32).cast_const();
     let mut c: u8 = arr2[(*p1) as usize];
     c = arr2[(*p1) as usize];
     let mut p2: *mut i32 = (&mut x as *mut i32);

tests/unit/out/unsafe/huffman.rs

@@ -6,7 +6,6 @@ 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 MinHeapNode {
     pub data: u8,
@@ -41,7 +40,6 @@ pub unsafe fn Swap_0(a: *mut MinHeapNode, b: *mut MinHeapNode) {
     })
     .clone();
 }
-#[repr(C)]
 #[derive(Default)]
 pub struct MinHeap {
     pub size: i32,
@@ -241,7 +239,7 @@ pub unsafe fn CollectCodes_4(
             CollectCodes_4(_root, _arr, _top, _out, _next)
         });
     }
-    if (unsafe { (*root).IsLeaf() }) {
+    if (unsafe { (*root.cast_const()).IsLeaf() }) {
         (unsafe {
             let _arr: *mut Option<Box<[i32]>> = arr;
             let _top: i32 = top;

tests/unit/out/unsafe/main.rs

@@ -18,7 +18,7 @@ pub fn main() {
 }
 unsafe fn main_0(mut argc: i32, mut argv: *mut *mut u8) -> i32 {
     let mut s: Vec<u8> = {
-        let s = (*argv.offset((0) as isize));
+        let s = (*argv.offset((0) as isize)).cast_const();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
     assert!(((argc) == (1)));

tests/unit/out/unsafe/pointer_diff.rs

@@ -13,7 +13,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: [i32; 5] = [1, 2, 3, 4, 5];
-    let mut p0: *const i32 = (&mut a[(0) as usize] as *mut i32);
-    let mut p1: *const i32 = (&mut a[(4) as usize] as *mut i32);
+    let mut p0: *const i32 = (&mut a[(0) as usize] as *mut i32).cast_const();
+    let mut p1: *const i32 = (&mut a[(4) as usize] as *mut i32).cast_const();
     return ((((p1 as usize - p0 as usize) / ::std::mem::size_of::<i32>()) as u64) as i32);
 }

tests/unit/out/unsafe/pointer_eq.rs

@@ -13,11 +13,11 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut x: i32 = 5;
-    let mut p1: *const i32 = (&mut x as *mut i32);
-    let mut p2: *const i32 = (&mut x as *mut i32);
+    let mut p1: *const i32 = (&mut x as *mut i32).cast_const();
+    let mut p2: *const i32 = (&mut x as *mut i32).cast_const();
     assert!(((p1) == (p2)));
     let mut y: i32 = 5;
-    let mut p3: *const i32 = (&mut y as *mut i32);
+    let mut p3: *const i32 = (&mut y as *mut i32).cast_const();
     assert!(((p1) != (p3)));
     let mut arr: [i32; 3] = [1, 2, 3];
     let mut p: *mut i32 = arr.as_mut_ptr();

tests/unit/out/unsafe/pointer_neq.rs

@@ -13,8 +13,8 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut x: i32 = 5;
-    let mut p1: *const i32 = (&mut x as *mut i32);
-    let mut p2: *const i32 = (&mut x as *mut i32);
+    let mut p1: *const i32 = (&mut x as *mut i32).cast_const();
+    let mut p2: *const i32 = (&mut x as *mut i32).cast_const();
     if ((p1) != (p2)) {
         return 1;
     } else {

tests/unit/out/unsafe/pointer_offset.rs

@@ -14,7 +14,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut out: i32 = 0;
     let mut arr: [i32; 5] = [1, 2, 3, 4, 0];
-    let mut ptr: *const i32 = (&mut arr[(0) as usize] as *mut i32);
+    let mut ptr: *const i32 = (&mut arr[(0) as usize] as *mut i32).cast_const();
     'loop_: while ((*ptr) != (0)) {
         out += (*ptr);
         ptr.prefix_inc();
@@ -29,7 +29,7 @@ unsafe fn main_0() -> i32 {
         out += (*ptr);
         ptr.postfix_dec();
     }
-    let mut ptr: *const i32 = (&mut arr[(3) as usize] as *mut i32);
+    let mut ptr: *const i32 = (&mut arr[(3) as usize] as *mut i32).cast_const();
     'loop_: while ((*ptr) != (2)) {
         out += (*ptr);
         ptr.prefix_dec();

tests/unit/out/unsafe/polymorphism.rs

@@ -9,15 +9,13 @@ use std::rc::Rc;
 pub unsafe trait Animal {
     unsafe fn bark(&self) -> bool;
 }
-#[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Dog {}
 unsafe impl Animal for Dog {
     unsafe fn bark(&self) -> bool {
         return true;
     }
 }
-#[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Cat {}
 impl Cat {
@@ -38,9 +36,9 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut dog: Dog = <Dog>::default();
     let mut animal: *mut dyn Animal = (&mut dog as *mut Dog);
-    let mut eat1: bool = (unsafe { (*animal).bark() });
+    let mut eat1: bool = (unsafe { (*animal.cast_const()).bark() });
     let mut cat: Cat = <Cat>::default();
     animal = (&mut cat as *mut Cat);
-    let mut eat2: bool = (unsafe { (*animal).bark() });
+    let mut eat2: bool = (unsafe { (*animal.cast_const()).bark() });
     return (((eat1) && (!eat2)) as i32);
 }