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

#![cfg(feature = "NSDictionary")]
#![cfg(feature = "NSString")]
#![cfg(feature = "NSObject")]
use alloc::{format, vec};

use objc2::rc::{autoreleasepool, Retained};

use crate::Foundation::{NSDictionary, NSObject, NSString};

fn sample_dict(key: &str) -> Retained<NSDictionary<NSString, NSObject>> {
    let string = NSString::from_str(key);
    let obj = NSObject::new();
    NSDictionary::from_vec(&[&*string], vec![obj])
}

#[test]
fn test_len() {
    let dict = sample_dict("abcd");
    assert_eq!(dict.len(), 1);
}

#[test]
fn test_get() {
    let dict = sample_dict("abcd");

    let string = NSString::from_str("abcd");
    assert!(dict.get(&string).is_some());

    let string = NSString::from_str("abcde");
    assert!(dict.get(&string).is_none());
}

#[test]
fn test_keys() {
    let dict = sample_dict("abcd");
    let keys = dict.keys_vec();

    assert_eq!(keys.len(), 1);
    autoreleasepool(|pool| {
        assert_eq!(keys[0].as_str(pool), "abcd");
    });
}

#[test]
fn test_values() {
    let dict = sample_dict("abcd");
    let vals = dict.values_vec();

    assert_eq!(vals.len(), 1);
}

#[test]
fn test_keys_and_objects() {
    let dict = sample_dict("abcd");
    let (keys, objs) = dict.to_vecs();

    assert_eq!(keys.len(), 1);
    assert_eq!(objs.len(), 1);
    autoreleasepool(|pool| {
        assert_eq!(keys[0].as_str(pool), "abcd");
    });
    assert_eq!(objs[0], dict.get(keys[0]).unwrap());
}

#[test]
#[cfg(feature = "NSEnumerator")]
fn test_iter_keys() {
    let dict = sample_dict("abcd");
    assert_eq!(dict.keys().count(), 1);
    autoreleasepool(|pool| {
        assert_eq!(dict.keys().next().unwrap().as_str(pool), "abcd");
    });
}

#[test]
#[cfg(feature = "NSEnumerator")]
fn test_iter_values() {
    let dict = sample_dict("abcd");
    assert_eq!(dict.values().count(), 1);
}

#[test]
#[cfg(feature = "NSArray")]
fn test_arrays() {
    let dict = sample_dict("abcd");

    let keys = unsafe { dict.allKeys() };
    assert_eq!(keys.len(), 1);
    autoreleasepool(|pool| {
        assert_eq!(keys[0].as_str(pool), "abcd");
    });

    // let objs = dict.to_array();
    // assert_eq!(objs.len(), 1);
}

#[test]
fn test_debug() {
    let key = NSString::from_str("a");
    let val = NSString::from_str("b");
    let dict = NSDictionary::from_id_slice(&[&*key], &[val]);
    assert_eq!(format!("{dict:?}"), r#"{"a": "b"}"#);
}

#[test]
fn new_different_lengths() {
    let dict = NSDictionary::from_id_slice(
        &[
            &*NSString::from_str("a"),
            &*NSString::from_str("b"),
            &*NSString::from_str("c"),
        ],
        &[NSObject::new(), NSObject::new()],
    );
    assert_eq!(dict.len(), 2);
}