libobs-wrapper 9.0.4+32.0.2

A safe wrapper around libobs
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(test)]
mod tests {
    use super::super::ObsString;

    #[test]
    fn test_obs_string_new() {
        let obs_string = ObsString::new("test_string");
        assert_eq!(format!("{}", obs_string), "test_string");
    }

    #[test]
    fn test_obs_string_new_with_nul_bytes() {
        // NUL bytes should be stripped
        let obs_string = ObsString::new("test\0string");
        assert_eq!(format!("{}", obs_string), "teststring");
    }

    #[test]
    fn test_obs_string_from_str() {
        let obs_string: ObsString = "hello".into();
        assert_eq!(format!("{}", obs_string), "hello");
    }

    #[test]
    fn test_obs_string_from_str_with_nul() {
        let obs_string: ObsString = "hel\0lo".into();
        assert_eq!(format!("{}", obs_string), "hello");
    }

    #[test]
    fn test_obs_string_from_string() {
        let s = String::from("test_value");
        let obs_string: ObsString = s.into();
        assert_eq!(format!("{}", obs_string), "test_value");
    }

    #[test]
    fn test_obs_string_from_string_with_nul() {
        let s = String::from("test\0value");
        let obs_string: ObsString = s.into();
        assert_eq!(format!("{}", obs_string), "testvalue");
    }

    #[test]
    fn test_obs_string_from_vec_u8() {
        let bytes = b"hello".to_vec();
        let obs_string: ObsString = bytes.into();
        assert_eq!(format!("{}", obs_string), "hello");
    }

    #[test]
    fn test_obs_string_from_vec_u8_with_nul() {
        let bytes = vec![104, 101, 0, 108, 108, 111]; // "he\0llo"
        let obs_string: ObsString = bytes.into();
        assert_eq!(format!("{}", obs_string), "hello");
    }

    #[test]
    fn test_obs_string_empty() {
        let obs_string = ObsString::new("");
        assert_eq!(format!("{}", obs_string), "");
    }

    #[test]
    fn test_obs_string_clone() {
        let obs_string1 = ObsString::new("clone_test");
        let obs_string2 = obs_string1.clone();
        assert_eq!(format!("{}", obs_string1), format!("{}", obs_string2));
    }

    #[test]
    fn test_obs_string_eq() {
        let obs_string1 = ObsString::new("equal");
        let obs_string2 = ObsString::new("equal");
        assert_eq!(obs_string1, obs_string2);
    }

    #[test]
    fn test_obs_string_ne() {
        let obs_string1 = ObsString::new("value1");
        let obs_string2 = ObsString::new("value2");
        assert_ne!(obs_string1, obs_string2);
    }

    #[test]
    fn test_obs_string_as_ptr_not_null() {
        let obs_string = ObsString::new("pointer_test");
        let ptr = obs_string.as_ptr();
        assert!(!ptr.0.is_null());
    }

    #[test]
    fn test_obs_string_default() {
        let obs_string = ObsString::default();
        assert_eq!(format!("{}", obs_string), "");
    }

    #[test]
    fn test_obs_string_ord() {
        let obs_string1 = ObsString::new("aaa");
        let obs_string2 = ObsString::new("bbb");
        assert!(obs_string1 < obs_string2);
    }

    #[test]
    fn test_obs_string_unicode() {
        let obs_string = ObsString::new("こんにちは");
        assert_eq!(format!("{}", obs_string), "こんにちは");
    }

    #[test]
    fn test_obs_string_special_chars() {
        let obs_string = ObsString::new("!@#$%^&*()");
        assert_eq!(format!("{}", obs_string), "!@#$%^&*()");
    }
}