Add send_sync_in_statics test

Author: lucic71

tests/unit/out/refcount/send_sync_in_statics.rs

@@ -0,0 +1,58 @@
+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 Entry {
+    pub name: Value<Ptr<u8>>,
+    pub p: Value<Ptr<i32>>,
+}
+impl Clone for Entry {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            name: Rc::new(RefCell::new((*self.name.borrow()).clone())),
+            p: Rc::new(RefCell::new((*self.p.borrow()).clone())),
+        };
+        this
+    }
+}
+impl ByteRepr for Entry {}
+thread_local!(
+    pub static single_entry: Value<Entry> = Rc::new(RefCell::new(Entry {
+        name: Rc::new(RefCell::new(Ptr::from_string_literal("alone"))),
+        p: Rc::new(RefCell::new(Default::default())),
+    }));
+);
+thread_local!(
+    pub static entries: Value<Box<[Entry]>> = Rc::new(RefCell::new(Box::new([
+        Entry {
+            name: Rc::new(RefCell::new(Ptr::from_string_literal("first"))),
+            p: Rc::new(RefCell::new(Default::default())),
+        },
+        Entry {
+            name: Rc::new(RefCell::new(Ptr::from_string_literal("second"))),
+            p: Rc::new(RefCell::new(Default::default())),
+        },
+    ])));
+);
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!((*(*single_entry.with(Value::clone).borrow()).p.borrow()).is_null());
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < 2) {
+        assert!(
+            (*(*entries.with(Value::clone).borrow())[(*i.borrow()) as usize]
+                .p
+                .borrow())
+            .is_null()
+        );
+        (*i.borrow_mut()).prefix_inc();
+    }
+    return 0;
+}

tests/unit/out/unsafe/send_sync_in_statics.rs

@@ -0,0 +1,44 @@
+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 Entry {
+    pub name: *const u8,
+    pub p: *mut i32,
+}
+// SAFETY: preserves unsafe C semantics; thread-safety is the programmer's responsibility
+unsafe impl Sync for Entry {}
+pub static single_entry: Entry = Entry {
+    name: b"alone\0".as_ptr(),
+    p: std::ptr::null_mut(),
+};
+pub static entries: [Entry; 2] = [
+    Entry {
+        name: b"first\0".as_ptr(),
+        p: std::ptr::null_mut(),
+    },
+    Entry {
+        name: b"second\0".as_ptr(),
+        p: std::ptr::null_mut(),
+    },
+];
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    assert!((single_entry.p).is_null());
+    let mut i: i32 = 0;
+    'loop_: while ((i) < (2)) {
+        assert!((entries[(i) as usize].p).is_null());
+        i.prefix_inc();
+    }
+    return 0;
+}

tests/unit/send_sync_in_statics.cpp

@@ -0,0 +1,22 @@
+#include <cassert>
+#include <cstddef>
+
+struct Entry {
+  const char *name;
+  int *p;
+};
+
+static const Entry single_entry = {"alone", nullptr};
+
+static const Entry entries[2] = {
+    {"first", nullptr},
+    {"second", nullptr},
+};
+
+int main() {
+  assert(single_entry.p == nullptr);
+  for (int i = 0; i < 2; ++i) {
+    assert(entries[i].p == nullptr);
+  }
+  return 0;
+}