vsdb 16.3.6

A std-collection-like database
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

use serde::{Deserialize, Serialize};
use vsdb::{basic::orphan::Orphan, vsdb_set_base_dir};

/// One process-wide base-dir pick: `vsdb_set_base_dir` publishes via
/// `env::set_var`, which is unsound to race — serialize it behind a
/// `Once` so parallel tests in this binary cannot touch the env
/// concurrently (losers reuse the winner's dir; data stays disjoint
/// via globally-unique prefixes).
fn setup() {
    use std::sync::Once;
    static INIT: Once = Once::new();
    INIT.call_once(|| {
        let _ =
            vsdb_set_base_dir(format!("/tmp/vsdb_testing/{}", rand::random::<u64>()));
    });
}

#[test]
fn basic_cases() {
    setup();

    assert_eq!(Orphan::new(0), 0);
    assert!(Orphan::new(111) > 0);
    assert!(Orphan::new(111) >= 0);
    assert!(Orphan::new(0) < 111);
    assert!(Orphan::new(0) <= 111);

    assert_eq!(Orphan::new(0), Orphan::new(0));
    assert!(Orphan::new(111) > Orphan::new(0));
    assert!(Orphan::new(111) >= Orphan::new(111));
    assert!(Orphan::new(0) < Orphan::new(111));
    assert!(Orphan::new(111) <= Orphan::new(111));

    assert_eq!(Orphan::new(111) + 111, 222);
    assert_eq!(Orphan::new(111) - 111, 0);
    assert_eq!(Orphan::new(111) * 111, 111 * 111);
    assert_eq!(Orphan::new(111) / 2, 55);
    assert_eq!(Orphan::new(111) % 2, 1);

    assert_eq!(-Orphan::new(111), -111);
    assert_eq!(!Orphan::new(111), !111);

    assert_eq!(Orphan::new(111) >> 2, 111 >> 2);
    assert_eq!(Orphan::new(111) << 2, 111 << 2);

    assert_eq!(Orphan::new(111) | 2, 111 | 2);
    assert_eq!(Orphan::new(111) & 2, 111 & 2);
    assert_eq!(Orphan::new(111) ^ 2, 111 ^ 2);

    let mut v = Orphan::new(1);
    v += 1;
    assert_eq!(v, 2);
    v *= 100;
    assert_eq!(v, 200);
    v -= 1;
    assert_eq!(v, 199);
    v /= 10;
    assert_eq!(v, 19);
    v %= 10;
    assert_eq!(v, 9);

    *v.get_mut() = -v.get_value();
    assert_eq!(v, -9);

    *v.get_mut() = !v.get_value();
    assert_eq!(v, !-9);

    *v.get_mut() = 732;
    v >>= 2;
    assert_eq!(v, 732 >> 2);

    *v.get_mut() = 732;
    v <<= 2;
    assert_eq!(v, 732 << 2);

    *v.get_mut() = 732;
    v |= 2;
    assert_eq!(v, 732 | 2);

    *v.get_mut() = 732;
    v &= 2;
    assert_eq!(v, 732 & 2);

    *v.get_mut() = 732;
    v ^= 2;
    assert_eq!(v, 732 ^ 2);
}

#[test]
fn custom_types() {
    setup();
    #[derive(
        Default, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize,
    )]
    struct Foo {
        a: i32,
        b: String,
        c: bool,
    }
    assert_eq!(Orphan::new(Foo::default()), Foo::default());
    assert_eq!(Orphan::new(Foo::default()), Orphan::new(Foo::default()));

    assert!(
        Orphan::new(Foo::default())
            < Foo {
                a: 1,
                b: "".to_string(),
                c: true
            }
    );
    assert!(
        Orphan::new(Foo::default())
            <= Foo {
                a: 1,
                b: "".to_string(),
                c: true
            }
    );

    assert!(Orphan::new(Foo::default()) >= Foo::default());
    assert!(Orphan::new(Foo::default()) >= Orphan::new(Foo::default()));
}