type-set 0.3.2

A set of heterogeneous types
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::{
    panic::{catch_unwind, AssertUnwindSafe},
    process::Termination,
};
use test_harness::test;
use type_set::{entry::Entry, TypeSet};

fn harness<T: Termination>(f: impl FnOnce() -> T) -> T {
    let _ = env_logger::builder().is_test(true).try_init();
    f()
}

struct MyCustomStruct;

#[test(harness)]
fn debug() {
    let mut set = TypeSet::new()
        .with("hello")
        .with(1usize)
        .with(MyCustomStruct);

    assert_eq!(
        r#"TypeSet({"&str", "tests::MyCustomStruct", "usize"})"#,
        format!("{set:?}")
    );

    assert_eq!(
        "Occupied(OccupiedEntry<&str>(\"hello\"))",
        format!("{:?}", set.entry::<&'static str>())
    );

    assert_eq!(
        "Vacant(VacantEntry<alloc::string::String>)",
        format!("{:?}", set.entry::<String>())
    );
}

#[test(harness)]
fn smoke() {
    let mut set = TypeSet::new();
    assert_eq!(set.len(), 0);
    assert!(set.is_empty());
    assert!(!set.contains::<bool>());
    set.insert(true);
    assert!(set.contains::<bool>());
    assert!(!set.is_empty());
    assert_eq!(set.len(), 1);
    assert!(set.get::<bool>().unwrap());
    set.insert(false);
    assert_eq!(set.len(), 1);
    assert!(!set.get::<bool>().unwrap());

    assert_eq!(*set.entry().or_insert("hello"), "hello");
    set.insert(String::from("hello"));
    assert_eq!(
        *set.entry()
            .and_modify(|h: &mut String| h.push_str(" world"))
            .or_default(),
        "hello world"
    );

    set.get_mut::<String>().unwrap().make_ascii_uppercase();
    assert_eq!(*set.get_or_insert(String::from("unused")), "HELLO WORLD");
    assert_eq!(
        *set.get_or_insert_with(|| String::from("unused")),
        "HELLO WORLD"
    );
    assert_eq!(*set.get_or_insert_default::<String>(), "HELLO WORLD");
    assert_eq!(set.take::<String>().unwrap(), "HELLO WORLD");
    assert_eq!(set.take::<String>(), None);
}

#[test(harness)]
fn merge() {
    let mut set_a = TypeSet::new().with(8u8).with("hello");
    let set_b = TypeSet::new().with(32u32).with("world");
    set_a.merge(set_b);
    assert_eq!(set_a.get::<u8>(), Some(&8));
    assert_eq!(set_a.get::<u32>(), Some(&32));
    assert_eq!(set_a.get::<&'static str>(), Some(&"world"));
    assert_eq!(set_a.len(), 3);
}

#[test(harness)]
fn entry() {
    let mut set = TypeSet::new();
    let entry = set.entry::<String>();
    assert!(entry.is_empty());
    let vacant_entry = entry.unwrap_vacant();
    vacant_entry.insert("hello".into());

    let vacant = set.entry::<usize>().unwrap_vacant();
    assert!(Entry::from(vacant).is_empty()); // sure it's a bit contrived

    let mut occupied_entry = set.entry::<String>().unwrap_occupied();
    assert_eq!(&**occupied_entry, "hello"); //deref
    assert_eq!(occupied_entry.get(), "hello");
    occupied_entry.get_mut().push_str(" world");
    occupied_entry.make_ascii_uppercase(); //deref mut

    set.entry::<String>().into_mut().unwrap().push('!');

    assert_eq!(set.entry::<String>().take().unwrap(), "HELLO WORLD!");

    assert!(set.entry::<String>().into_occupied().is_none());
    let vacant = set.entry::<String>();

    assert_eq!(
        *catch_unwind(AssertUnwindSafe(move || { vacant.unwrap_occupied() }))
            .unwrap_err()
            .downcast::<String>()
            .unwrap(),
        "expected an occupied type-set entry for alloc::string::String, but was vacant"
    );

    assert_eq!(*set.entry::<usize>().or_insert(10), 10);
    assert_eq!(
        *set.entry()
            .and_modify(|x: &mut usize| *x += 10)
            .or_default(),
        20
    );

    let occupied = set.entry::<usize>();
    assert_eq!(
        *catch_unwind(AssertUnwindSafe(move || { occupied.unwrap_vacant() }))
            .unwrap_err()
            .downcast::<String>()
            .unwrap(),
        "expected a vacant type-set entry for usize, but was occupied"
    );

    assert_eq!(
        *set.entry::<String>()
            .and_modify(|_| panic!("never called"))
            .or_insert_with(|| String::from("hello")),
        "hello"
    );

    assert!(!Entry::from(set.entry::<String>().unwrap_occupied()).is_empty())
}