Update expected output

Author: lucic71

tests/unit/out/refcount/union_cross_arm_cast.rs

@@ -0,0 +1,80 @@
+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()]
+pub struct shape_a {
+    pub code: Value<u16>,
+    pub pad: Value<Box<[u8]>>,
+}
+impl ByteRepr for shape_a {}
+#[derive()]
+pub struct shape_b {
+    pub code: Value<u16>,
+    pub lo: Value<u16>,
+    pub mid: Value<u32>,
+    pub fill: Value<Box<[u8]>>,
+    pub tail: Value<u32>,
+}
+impl ByteRepr for shape_b {}
+#[derive()]
+pub struct Container_anon_0 {
+    pub a: Value<shape_a>,
+    pub b: Value<shape_b>,
+    pub raw_: Value<Box<[u8]>>,
+}
+impl ByteRepr for Container_anon_0 {}
+#[derive(Default)]
+pub struct Container {
+    pub len: Value<u32>,
+    pub u: Value<Container_anon_0>,
+}
+impl ByteRepr for Container {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Container> = <Value<Container>>::default();
+    {
+        ((c.as_pointer()) as Ptr<Container>).to_any().memset(
+            (0) as u8,
+            ::std::mem::size_of::<Container>() as u64 as usize,
+        );
+        ((c.as_pointer()) as Ptr<Container>).to_any().clone()
+    };
+    (*(*(*(*c.borrow()).u.borrow()).a.borrow()).code.borrow_mut()) = 10_u16;
+    (*(*c.borrow()).len.borrow_mut()) = (::std::mem::size_of::<shape_b>() as u64 as u32);
+    (*(*((((*(*c.borrow()).u.borrow()).a.as_pointer())
+        .to_strong()
+        .as_pointer() as AnyPtr)
+        .cast::<shape_b>()
+        .expect("ub:wrong type"))
+    .upgrade()
+    .deref())
+    .tail
+    .borrow_mut()) = 3735928559_u32;
+    assert!(((*(*(*(*c.borrow()).u.borrow()).b.borrow()).tail.borrow()) == 3735928559_u32));
+    assert!((((*(*(*(*c.borrow()).u.borrow()).b.borrow()).code.borrow()) as i32) == 10));
+    (*(*(*(*c.borrow()).u.borrow()).b.borrow()).lo.borrow_mut()) = 8080_u16;
+    assert!(
+        ((((((*(*c.borrow()).u.borrow()).raw_.as_pointer())
+            .to_strong()
+            .as_pointer() as Ptr::<u8>)
+            .offset((2) as isize)
+            .read()) as i32)
+            == 144)
+    );
+    assert!(
+        ((((((*(*c.borrow()).u.borrow()).raw_.as_pointer())
+            .to_strong()
+            .as_pointer() as Ptr::<u8>)
+            .offset((3) as isize)
+            .read()) as i32)
+            == 31)
+    );
+    return 0;
+}

tests/unit/out/refcount/union_field_alignment.rs

@@ -0,0 +1,30 @@
+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()]
+pub struct node_anon_0 {
+    pub bytes: Value<Box<[u8]>>,
+    pub aligner: Value<AnyPtr>,
+}
+impl ByteRepr for node_anon_0 {}
+#[derive(Default)]
+pub struct node {
+    pub next: Value<Ptr<node>>,
+    pub x: Value<node_anon_0>,
+}
+impl ByteRepr for node {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let n: Value<node> = <Value<node>>::default();
+    (*(*n.borrow()).next.borrow_mut()) = Default::default();
+    (*(*(*n.borrow()).x.borrow()).bytes.borrow_mut())[(0) as usize] = 171_u8;
+    assert!((((*(*(*n.borrow()).x.borrow()).bytes.borrow())[(0) as usize] as i32) == 171));
+    return 0;
+}

tests/unit/out/refcount/union_flex_array_member.rs

@@ -0,0 +1,73 @@
+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()]
+pub struct node_anon_0 {
+    pub bytes: Value<Box<[u8]>>,
+    pub aligner: Value<AnyPtr>,
+}
+impl ByteRepr for node_anon_0 {}
+#[derive(Default)]
+pub struct node {
+    pub len: Value<u64>,
+    pub x: Value<node_anon_0>,
+}
+impl ByteRepr for node {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let tail_size: Value<u64> = Rc::new(RefCell::new(32_u64));
+    let n: Value<Ptr<node>> = Rc::new(RefCell::new(
+        ({
+            let ___size: u64 =
+                (::std::mem::size_of::<node>() as u64 as u64).wrapping_add((*tail_size.borrow()));
+            malloc_0(___size)
+        })
+        .cast::<node>()
+        .expect("ub:wrong type"),
+    ));
+    (*(*(*n.borrow()).upgrade().deref()).len.borrow_mut()) = (*tail_size.borrow());
+    let i: Value<u64> = Rc::new(RefCell::new(0_u64));
+    'loop_: while ((*i.borrow()) < (*tail_size.borrow())) {
+        let __rhs = ((((*i.borrow()) & 255_u64) as u64) as u8);
+        (*(*(*(*n.borrow()).upgrade().deref()).x.borrow())
+            .bytes
+            .borrow_mut())[(*i.borrow()) as usize] = __rhs;
+        (*i.borrow_mut()).postfix_inc();
+    }
+    let i: Value<u64> = Rc::new(RefCell::new(0_u64));
+    'loop_: while ((*i.borrow()) < (*tail_size.borrow())) {
+        assert!({
+            let _lhs = ((*(*(*(*n.borrow()).upgrade().deref()).x.borrow())
+                .bytes
+                .borrow())[(*i.borrow()) as usize] as i32);
+            _lhs == (((((*i.borrow()) & 255_u64) as u64) as u8) as i32)
+        });
+        (*i.borrow_mut()).postfix_inc();
+    }
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(
+        (((*(*(*n.borrow()).upgrade().deref()).x.borrow())
+            .bytes
+            .as_pointer() as Ptr<u8>)
+            .offset(10 as isize)),
+    ));
+    assert!(((((*p.borrow()).read()) as i32) == 10));
+    (*p.borrow()).write(170_u8);
+    assert!(
+        (((*(*(*(*n.borrow()).upgrade().deref()).x.borrow())
+            .bytes
+            .borrow())[(10) as usize] as i32)
+            == 170)
+    );
+    ({
+        let ___ptr: AnyPtr = ((*n.borrow()).clone() as Ptr<node>).to_any();
+        free_1(___ptr)
+    });
+    return 0;
+}

tests/unit/out/refcount/union_memset_memcpy.rs

@@ -0,0 +1,107 @@
+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()]
+pub struct shape_a {
+    pub code: Value<u16>,
+    pub pad: Value<Box<[u8]>>,
+}
+impl ByteRepr for shape_a {}
+#[derive()]
+pub struct shape_b {
+    pub code: Value<u16>,
+    pub lo: Value<u16>,
+    pub hi: Value<u32>,
+    pub fill: Value<Box<[u8]>>,
+}
+impl ByteRepr for shape_b {}
+#[derive()]
+pub struct Container_anon_0 {
+    pub a: Value<shape_a>,
+    pub b: Value<shape_b>,
+    pub raw_: Value<Box<[u8]>>,
+}
+impl ByteRepr for Container_anon_0 {}
+#[derive(Default)]
+pub struct Container {
+    pub view: Value<Container_anon_0>,
+}
+impl ByteRepr for Container {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Container> = <Value<Container>>::default();
+    {
+        ((c.as_pointer()) as Ptr<Container>).to_any().memset(
+            (0) as u8,
+            ::std::mem::size_of::<Container>() as u64 as usize,
+        );
+        ((c.as_pointer()) as Ptr<Container>).to_any().clone()
+    };
+    assert!((((*(*(*(*c.borrow()).view.borrow()).a.borrow()).code.borrow()) as i32) == 0));
+    assert!((((*(*(*(*c.borrow()).view.borrow()).b.borrow()).lo.borrow()) as i32) == 0));
+    assert!((((*(*(*c.borrow()).view.borrow()).raw_.borrow())[(0) as usize] as i32) == 0));
+    assert!((((*(*(*c.borrow()).view.borrow()).raw_.borrow())[(255) as usize] as i32) == 0));
+    let src: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        0_u8,
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+    ])));
+    (*src.borrow_mut())[(0) as usize] = 2_u8;
+    (*src.borrow_mut())[(2) as usize] = 80_u8;
+    (*src.borrow_mut())[(3) as usize] = 0_u8;
+    (*src.borrow_mut())[(4) as usize] = 127_u8;
+    (*src.borrow_mut())[(5) as usize] = 0_u8;
+    (*src.borrow_mut())[(6) as usize] = 0_u8;
+    (*src.borrow_mut())[(7) as usize] = 1_u8;
+    let len: Value<u64> = Rc::new(RefCell::new(16_u64));
+    assert!(((*len.borrow()) <= ::std::mem::size_of::<[u8; 256]>() as u64));
+    {
+        (((*(*c.borrow()).view.borrow()).raw_.as_pointer()) as Ptr<u8>)
+            .to_any()
+            .memcpy(
+                &((src.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+                (*len.borrow()) as usize,
+            );
+        (((*(*c.borrow()).view.borrow()).raw_.as_pointer()) as Ptr<u8>)
+            .to_any()
+            .clone()
+    };
+    assert!((((*(*(*(*c.borrow()).view.borrow()).b.borrow()).code.borrow()) as i32) == 2));
+    assert!(
+        ((((((*(*(*c.borrow()).view.borrow()).b.borrow()).lo.as_pointer())
+            .to_strong()
+            .as_pointer() as Ptr::<u8>)
+            .offset((0) as isize)
+            .read()) as i32)
+            == 80)
+    );
+    {
+        ((c.as_pointer()) as Ptr<Container>).to_any().memset(
+            (0) as u8,
+            ::std::mem::size_of::<Container>() as u64 as usize,
+        );
+        ((c.as_pointer()) as Ptr<Container>).to_any().clone()
+    };
+    assert!((((*(*(*(*c.borrow()).view.borrow()).b.borrow()).code.borrow()) as i32) == 0));
+    return 0;
+}

tests/unit/out/refcount/union_nested.rs

@@ -0,0 +1,78 @@
+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()]
+pub struct record {
+    pub code: Value<u16>,
+    pub pad: Value<Box<[u8]>>,
+}
+impl ByteRepr for record {}
+#[derive()]
+pub struct inner_anon_0 {
+    pub h: Value<record>,
+    pub raw_: Value<Box<[u8]>>,
+}
+impl ByteRepr for inner_anon_0 {}
+#[derive(Default)]
+pub struct inner {
+    pub view: Value<inner_anon_0>,
+}
+impl ByteRepr for inner {}
+#[derive(Default)]
+pub struct Outer_anon_0 {
+    pub h: Value<record>,
+    pub nested: Value<inner>,
+}
+impl ByteRepr for Outer_anon_0 {}
+#[derive(Default)]
+pub struct Outer {
+    pub kind: Value<i32>,
+    pub level: Value<i32>,
+    pub variant: Value<i32>,
+    pub len: Value<u32>,
+    pub body: Value<Outer_anon_0>,
+}
+impl ByteRepr for Outer {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let ex: Value<Outer> = <Value<Outer>>::default();
+    {
+        ((ex.as_pointer()) as Ptr<Outer>)
+            .to_any()
+            .memset((0) as u8, ::std::mem::size_of::<Outer>() as u64 as usize);
+        ((ex.as_pointer()) as Ptr<Outer>).to_any().clone()
+    };
+    (*(*ex.borrow()).kind.borrow_mut()) = 2;
+    (*(*ex.borrow()).level.borrow_mut()) = 1;
+    (*(*ex.borrow()).variant.borrow_mut()) = 6;
+    (*(*ex.borrow()).len.borrow_mut()) = (::std::mem::size_of::<record>() as u64 as u32);
+    (*(*(*(*ex.borrow()).body.borrow()).h.borrow())
+        .code
+        .borrow_mut()) = 2_u16;
+    (*(*(*(*ex.borrow()).body.borrow()).h.borrow())
+        .pad
+        .borrow_mut())[(0) as usize] = (('X' as i32) as u8);
+    assert!((((*(*(*(*ex.borrow()).body.borrow()).h.borrow()).code.borrow()) as i32) == 2));
+    assert!(
+        (((*(*(*(*ex.borrow()).body.borrow()).h.borrow()).pad.borrow())[(0) as usize] as i32)
+            == ('X' as i32))
+    );
+    assert!(
+        (((*(*(*(*(*(*ex.borrow()).body.borrow()).nested.borrow())
+            .view
+            .borrow())
+        .h
+        .borrow())
+        .code
+        .borrow()) as i32)
+            == 2)
+    );
+    return 0;
+}