objc2-foundation 0.2.2

Bindings to the Foundation framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

#![cfg(feature = "NSThread")]
use alloc::format;

use crate::Foundation::{is_main_thread, MainThreadMarker, NSThread};

#[test]
#[cfg_attr(
    feature = "gnustep-1-7",
    ignore = "Retrieving main thread is weirdly broken, only works with --test-threads=1"
)]
fn test_main_thread() {
    let current = NSThread::currentThread();
    let main = NSThread::mainThread();

    assert!(main.isMainThread());

    if main == current {
        assert!(current.isMainThread());
        assert!(is_main_thread());
    } else {
        assert!(!current.isMainThread());
        assert!(!is_main_thread());
    }
}

#[test]
fn test_not_main_thread() {
    let res = std::thread::spawn(|| (is_main_thread(), NSThread::currentThread().isMainThread()))
        .join()
        .unwrap();
    assert_eq!(res, (false, false));
}

#[test]
fn test_main_thread_auto_traits() {
    use std::panic::{RefUnwindSafe, UnwindSafe};

    fn assert_traits<T: Unpin + UnwindSafe + RefUnwindSafe + Sized>() {}

    assert_traits::<MainThreadMarker>();
}

#[test]
#[cfg_attr(
    feature = "gnustep-1-7",
    ignore = "Retrieving main thread is weirdly broken, only works with --test-threads=1"
)]
fn test_debug() {
    let thread = NSThread::mainThread();

    let actual = format!("{thread:?}");
    let expected = [
        // macOS 11
        format!("<NSThread: {thread:p}>{{number = 1, name = (null)}}"),
        format!("<NSThread: {thread:p}>{{number = 1, name = main}}"),
        // macOS 12
        format!("<_NSMainThread: {thread:p}>{{number = 1, name = (null)}}"),
        format!("<_NSMainThread: {thread:p}>{{number = 1, name = main}}"),
    ];
    assert!(
        expected.contains(&actual),
        "Expected one of {expected:?}, got {actual:?}",
    );

    // SAFETY: We don't use the marker for anything other than its Debug
    // impl, so this test doesn't actually need to run on the main thread!
    let marker = unsafe { MainThreadMarker::new_unchecked() };
    assert_eq!(format!("{marker:?}"), "MainThreadMarker");
}

#[test]
#[cfg(feature = "dispatch")]
#[cfg(feature = "NSThread")]
fn test_main_thread_bound_traits() {
    use crate::Foundation::MainThreadBound;

    struct Foo {
        _inner: *const (),
    }

    fn assert_send_sync<T: Send + Sync>() {}

    assert_send_sync::<MainThreadBound<MainThreadMarker>>();
    assert_send_sync::<MainThreadBound<Foo>>();

    fn foo<T>() {
        assert_send_sync::<MainThreadBound<T>>();
    }

    foo::<()>();
}

#[test]
#[cfg(feature = "dispatch")]
#[cfg(feature = "NSThread")]
fn test_main_thread_bound_into_inner() {
    use crate::Foundation::MainThreadBound;
    use core::cell::Cell;

    // SAFETY: For testing only
    let mtm = unsafe { MainThreadMarker::new_unchecked() };

    struct Foo<'a> {
        is_dropped: &'a Cell<bool>,
    }

    impl Drop for Foo<'_> {
        fn drop(&mut self) {
            self.is_dropped.set(true);
        }
    }

    let is_dropped = Cell::new(false);
    let foo = Foo {
        is_dropped: &is_dropped,
    };
    let foo = MainThreadBound::new(foo, mtm);
    assert!(!is_dropped.get());

    let foo = foo.into_inner(mtm);
    assert!(!is_dropped.get());

    drop(foo);
    assert!(is_dropped.get());
}