Add C struct test

Author: lucic71

tests/unit/c_struct.c

@@ -0,0 +1,51 @@
+#include <assert.h>
+
+struct Point {
+  int x;
+  int y;
+};
+
+struct Line {
+  struct Point start;
+  struct Point end;
+};
+
+struct Node {
+  int value;
+  struct Node *next;
+};
+
+struct Container {
+  struct Inner {
+    int a;
+    int b;
+  } inner;
+  enum Color { RED, GREEN, BLUE } color;
+  int count;
+};
+
+int main() {
+  struct Point p = {10, 20};
+  assert(p.x == 10);
+  assert(p.y == 20);
+
+  struct Line l = {{1, 2}, {3, 4}};
+  assert(l.start.x == 1);
+  assert(l.end.y == 4);
+
+  struct Node a = {1, 0};
+  struct Node b = {2, &a};
+  assert(b.next->value == 1);
+
+  struct Container c = {{5, 6}, GREEN, 42};
+  assert(c.inner.a == 5);
+  assert(c.inner.b == 6);
+  assert(c.color == GREEN);
+  assert(c.count == 42);
+
+  struct Container c2;
+  c2.color = BLUE;
+  assert(c2.color == 2);
+
+  return 0;
+}

tests/unit/out/refcount/c_struct.rs

@@ -0,0 +1,100 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Default)]
+pub struct Point {
+    pub x: Value<i32>,
+    pub y: Value<i32>,
+}
+impl ByteRepr for Point {}
+#[derive(Clone, Default)]
+pub struct Line {
+    pub start: Value<Point>,
+    pub end: Value<Point>,
+}
+impl ByteRepr for Line {}
+#[derive(Clone, Default)]
+pub struct Node {
+    pub value: Value<i32>,
+    pub next: Value<Ptr<Node>>,
+}
+impl ByteRepr for Node {}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Color {
+    #[default]
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2,
+}
+#[derive(Clone, Default)]
+pub struct Inner {
+    pub a: Value<i32>,
+    pub b: Value<i32>,
+}
+impl ByteRepr for Inner {}
+#[derive(Clone, Default)]
+pub struct Container {
+    pub inner: Value<Inner>,
+    pub color: Value<Color>,
+    pub count: Value<i32>,
+}
+impl ByteRepr for Container {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let p: Value<Point> = Rc::new(RefCell::new(Point {
+        x: Rc::new(RefCell::new(10)),
+        y: Rc::new(RefCell::new(20)),
+    }));
+    assert!(((*(*p.borrow()).x.borrow()) == 10));
+    assert!(((*(*p.borrow()).y.borrow()) == 20));
+    let l: Value<Line> = Rc::new(RefCell::new(Line {
+        start: Rc::new(RefCell::new(Point {
+            x: Rc::new(RefCell::new(1)),
+            y: Rc::new(RefCell::new(2)),
+        })),
+        end: Rc::new(RefCell::new(Point {
+            x: Rc::new(RefCell::new(3)),
+            y: Rc::new(RefCell::new(4)),
+        })),
+    }));
+    assert!(((*(*(*l.borrow()).start.borrow()).x.borrow()) == 1));
+    assert!(((*(*(*l.borrow()).end.borrow()).y.borrow()) == 4));
+    let a: Value<Node> = Rc::new(RefCell::new(Node {
+        value: Rc::new(RefCell::new(1)),
+        next: Rc::new(RefCell::new(Default::default())),
+    }));
+    let b: Value<Node> = Rc::new(RefCell::new(Node {
+        value: Rc::new(RefCell::new(2)),
+        next: Rc::new(RefCell::new((a.as_pointer()))),
+    }));
+    assert!(
+        ((*(*(*(*b.borrow()).next.borrow()).upgrade().deref())
+            .value
+            .borrow())
+            == 1)
+    );
+    let c: Value<Container> = Rc::new(RefCell::new(Container {
+        inner: Rc::new(RefCell::new(Inner {
+            a: Rc::new(RefCell::new(5)),
+            b: Rc::new(RefCell::new(6)),
+        })),
+        color: Rc::new(RefCell::new((Color::GREEN as Color))),
+        count: Rc::new(RefCell::new(42)),
+    }));
+    assert!(((*(*(*c.borrow()).inner.borrow()).a.borrow()) == 5));
+    assert!(((*(*(*c.borrow()).inner.borrow()).b.borrow()) == 6));
+    assert!((((*(*c.borrow()).color.borrow()) as u32) == (Color::GREEN as u32)));
+    assert!(((*(*c.borrow()).count.borrow()) == 42));
+    let c2: Value<Container> = <Value<Container>>::default();
+    (*(*c2.borrow()).color.borrow_mut()) = (Color::BLUE as Color);
+    assert!((((*(*c2.borrow()).color.borrow()) as u32) == 2_u32));
+    return 0;
+}

tests/unit/out/unsafe/c_struct.rs

@@ -0,0 +1,80 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::Seek;
+use std::io::{Read, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[derive(Clone, Default)]
+pub struct Point {
+    pub x: i32,
+    pub y: i32,
+}
+#[derive(Clone, Default)]
+pub struct Line {
+    pub start: Point,
+    pub end: Point,
+}
+#[derive(Clone, Default)]
+pub struct Node {
+    pub value: i32,
+    pub next: *mut Node,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Color {
+    #[default]
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2,
+}
+#[derive(Clone, Default)]
+pub struct Inner {
+    pub a: i32,
+    pub b: i32,
+}
+#[derive(Clone, Default)]
+pub struct Container {
+    pub inner: Inner,
+    pub color: Color,
+    pub count: i32,
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut p: Point = Point { x: 10, y: 20 };
+    assert!(((p.x) == (10)));
+    assert!(((p.y) == (20)));
+    let mut l: Line = Line {
+        start: Point { x: 1, y: 2 },
+        end: Point { x: 3, y: 4 },
+    };
+    assert!(((l.start.x) == (1)));
+    assert!(((l.end.y) == (4)));
+    let mut a: Node = Node {
+        value: 1,
+        next: Default::default(),
+    };
+    let mut b: Node = Node {
+        value: 2,
+        next: (&mut a as *mut Node),
+    };
+    assert!((((*b.next).value) == (1)));
+    let mut c: Container = Container {
+        inner: Inner { a: 5, b: 6 },
+        color: (Color::GREEN as Color),
+        count: 42,
+    };
+    assert!(((c.inner.a) == (5)));
+    assert!(((c.inner.b) == (6)));
+    assert!(((c.color as u32) == (Color::GREEN as u32)));
+    assert!(((c.count) == (42)));
+    let mut c2: Container = <Container>::default();
+    c2.color = (Color::BLUE as Color);
+    assert!(((c2.color as u32) == (2_u32)));
+    return 0;
+}