Update tests

Author: lucic71

tests/unit/out/refcount/anonymous_enum.rs

@@ -0,0 +1,84 @@
+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(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_3 {
+    #[default]
+    FIRST_A = 0,
+    FIRST_B = 1,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_11 {
+    #[default]
+    SECOND_A = 0,
+    SECOND_B = 1,
+}
+#[derive(Default)]
+pub struct S {
+    pub a: Value<i32>,
+}
+impl Clone for S {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            a: Rc::new(RefCell::new((*self.a.borrow()))),
+        };
+        this
+    }
+}
+impl ByteRepr for S {}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum TdEnum {
+    #[default]
+    TD_A = 0,
+    TD_B = 1,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_24 {
+    #[default]
+    FIELD_A = 0,
+    FIELD_B = 1,
+}
+#[derive(Default)]
+pub struct WithAnonField {
+    pub a: Value<i32>,
+    pub field: Value<anon_enum_24>,
+}
+impl Clone for WithAnonField {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            a: Rc::new(RefCell::new((*self.a.borrow()))),
+            field: Rc::new(RefCell::new((*self.field.borrow()).clone())),
+        };
+        this
+    }
+}
+impl ByteRepr for WithAnonField {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    #[derive(Clone, Copy, PartialEq, Debug, Default)]
+    enum anon_enum_31 {
+        #[default]
+        THIRD_A = 0,
+        THIRD_B = 1,
+    };
+    assert!(((anon_enum_3::FIRST_A as i32) != (anon_enum_3::FIRST_B as i32)));
+    assert!(((anon_enum_11::SECOND_A as i32) != (anon_enum_11::SECOND_B as i32)));
+    assert!(((anon_enum_31::THIRD_A as i32) != (anon_enum_31::THIRD_B as i32)));
+    let td: Value<TdEnum> = Rc::new(RefCell::new(TdEnum::TD_A));
+    assert!((((*td.borrow()) as i32) == (TdEnum::TD_A as i32)));
+    (*td.borrow_mut()) = TdEnum::TD_B;
+    assert!((((*td.borrow()) as i32) == (TdEnum::TD_B as i32)));
+    let w: Value<WithAnonField> = Rc::new(RefCell::new(<WithAnonField>::default()));
+    (*(*w.borrow()).field.borrow_mut()) = anon_enum_24::FIELD_A;
+    assert!((((*(*w.borrow()).field.borrow()) as i32) == (anon_enum_24::FIELD_A as i32)));
+    (*(*w.borrow()).field.borrow_mut()) = anon_enum_24::FIELD_B;
+    assert!((((*(*w.borrow()).field.borrow()) as i32) == (anon_enum_24::FIELD_B as i32)));
+    return 0;
+}

tests/unit/out/refcount/anonymous_enum_c.rs

@@ -0,0 +1,67 @@
+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(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_3 {
+    #[default]
+    FIRST_A = 0,
+    FIRST_B = 1,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_11 {
+    #[default]
+    SECOND_A = 0,
+    SECOND_B = 1,
+}
+#[derive(Default)]
+pub struct S {
+    pub a: Value<i32>,
+}
+impl ByteRepr for S {}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum TdEnum {
+    #[default]
+    TD_A = 0,
+    TD_B = 1,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_24 {
+    #[default]
+    FIELD_A = 0,
+    FIELD_B = 1,
+}
+#[derive(Default)]
+pub struct WithAnonField {
+    pub a: Value<i32>,
+    pub field: Value<anon_enum_24>,
+}
+impl ByteRepr for WithAnonField {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    #[derive(Clone, Copy, PartialEq, Debug, Default)]
+    enum anon_enum_31 {
+        #[default]
+        THIRD_A = 0,
+        THIRD_B = 1,
+    };
+    assert!((anon_enum_3::FIRST_A != anon_enum_3::FIRST_B));
+    assert!((anon_enum_11::SECOND_A != anon_enum_11::SECOND_B));
+    assert!((anon_enum_31::THIRD_A != anon_enum_31::THIRD_B));
+    let td: Value<TdEnum> = Rc::new(RefCell::new((TdEnum::TD_A as TdEnum)));
+    assert!((((*td.borrow()) as u32) == (TdEnum::TD_A as u32)));
+    (*td.borrow_mut()) = (TdEnum::TD_B as TdEnum);
+    assert!((((*td.borrow()) as u32) == (TdEnum::TD_B as u32)));
+    let w: Value<WithAnonField> = <Value<WithAnonField>>::default();
+    (*(*w.borrow()).field.borrow_mut()) = (anon_enum_24::FIELD_A as anon_enum_24);
+    assert!((((*(*w.borrow()).field.borrow()) as u32) == (anon_enum_24::FIELD_A as u32)));
+    (*(*w.borrow()).field.borrow_mut()) = (anon_enum_24::FIELD_B as anon_enum_24);
+    assert!((((*(*w.borrow()).field.borrow()) as u32) == (anon_enum_24::FIELD_B as u32)));
+    return 0;
+}

tests/unit/out/unsafe/anonymous_enum.rs

@@ -0,0 +1,69 @@
+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;
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_3 {
+    #[default]
+    FIRST_A = 0,
+    FIRST_B = 1,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_11 {
+    #[default]
+    SECOND_A = 0,
+    SECOND_B = 1,
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct S {
+    pub a: i32,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum TdEnum {
+    #[default]
+    TD_A = 0,
+    TD_B = 1,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_24 {
+    #[default]
+    FIELD_A = 0,
+    FIELD_B = 1,
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct WithAnonField {
+    pub a: i32,
+    pub field: anon_enum_24,
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    #[derive(Clone, Copy, PartialEq, Debug, Default)]
+    enum anon_enum_31 {
+        #[default]
+        THIRD_A = 0,
+        THIRD_B = 1,
+    };
+    assert!(((anon_enum_3::FIRST_A as i32) != (anon_enum_3::FIRST_B as i32)));
+    assert!(((anon_enum_11::SECOND_A as i32) != (anon_enum_11::SECOND_B as i32)));
+    assert!(((anon_enum_31::THIRD_A as i32) != (anon_enum_31::THIRD_B as i32)));
+    let mut td: TdEnum = TdEnum::TD_A;
+    assert!(((td as i32) == (TdEnum::TD_A as i32)));
+    td = (TdEnum::TD_B).clone();
+    assert!(((td as i32) == (TdEnum::TD_B as i32)));
+    let mut w: WithAnonField = <WithAnonField>::default();
+    w.field = anon_enum_24::FIELD_A;
+    assert!(((w.field as i32) == (anon_enum_24::FIELD_A as i32)));
+    w.field = (anon_enum_24::FIELD_B).clone();
+    assert!(((w.field as i32) == (anon_enum_24::FIELD_B as i32)));
+    return 0;
+}

tests/unit/out/unsafe/anonymous_enum_c.rs

@@ -0,0 +1,69 @@
+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;
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_3 {
+    #[default]
+    FIRST_A = 0,
+    FIRST_B = 1,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_11 {
+    #[default]
+    SECOND_A = 0,
+    SECOND_B = 1,
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct S {
+    pub a: i32,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum TdEnum {
+    #[default]
+    TD_A = 0,
+    TD_B = 1,
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum anon_enum_24 {
+    #[default]
+    FIELD_A = 0,
+    FIELD_B = 1,
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct WithAnonField {
+    pub a: i32,
+    pub field: anon_enum_24,
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    #[derive(Clone, Copy, PartialEq, Debug, Default)]
+    enum anon_enum_31 {
+        #[default]
+        THIRD_A = 0,
+        THIRD_B = 1,
+    };
+    assert!(((anon_enum_3::FIRST_A) != (anon_enum_3::FIRST_B)));
+    assert!(((anon_enum_11::SECOND_A) != (anon_enum_11::SECOND_B)));
+    assert!(((anon_enum_31::THIRD_A) != (anon_enum_31::THIRD_B)));
+    let mut td: TdEnum = (TdEnum::TD_A as TdEnum);
+    assert!(((td as u32) == (TdEnum::TD_A as u32)));
+    td = (TdEnum::TD_B as TdEnum).clone();
+    assert!(((td as u32) == (TdEnum::TD_B as u32)));
+    let mut w: WithAnonField = <WithAnonField>::default();
+    w.field = (anon_enum_24::FIELD_A as anon_enum_24);
+    assert!(((w.field as u32) == (anon_enum_24::FIELD_A as u32)));
+    w.field = (anon_enum_24::FIELD_B as anon_enum_24).clone();
+    assert!(((w.field as u32) == (anon_enum_24::FIELD_B as u32)));
+    return 0;
+}