oxihuman-core 0.1.2

Core data structures, algorithms, and asset management for OxiHuman
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

#![allow(dead_code)]

/// Extended string builder with line and capacity utilities.
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct StringBuilderExt {
    buffer: String,
}

/// Creates a new empty string builder.
#[allow(dead_code)]
pub fn new_string_builder_ext() -> StringBuilderExt {
    StringBuilderExt {
        buffer: String::new(),
    }
}

/// Appends a string slice.
#[allow(dead_code)]
pub fn append_str(sb: &mut StringBuilderExt, s: &str) {
    sb.buffer.push_str(s);
}

/// Appends a single character.
#[allow(dead_code)]
pub fn append_char(sb: &mut StringBuilderExt, c: char) {
    sb.buffer.push(c);
}

/// Appends a string followed by a newline.
#[allow(dead_code)]
pub fn append_line(sb: &mut StringBuilderExt, s: &str) {
    sb.buffer.push_str(s);
    sb.buffer.push('\n');
}

/// Returns the current length in bytes.
#[allow(dead_code)]
pub fn builder_len(sb: &StringBuilderExt) -> usize {
    sb.buffer.len()
}

/// Converts to a String.
#[allow(dead_code)]
pub fn builder_to_string(sb: &StringBuilderExt) -> String {
    sb.buffer.clone()
}

/// Clears the builder.
#[allow(dead_code)]
pub fn builder_clear(sb: &mut StringBuilderExt) {
    sb.buffer.clear();
}

/// Returns the capacity.
#[allow(dead_code)]
pub fn builder_capacity(sb: &StringBuilderExt) -> usize {
    sb.buffer.capacity()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new() {
        let sb = new_string_builder_ext();
        assert_eq!(builder_len(&sb), 0);
    }

    #[test]
    fn test_append_str() {
        let mut sb = new_string_builder_ext();
        append_str(&mut sb, "hello");
        assert_eq!(builder_to_string(&sb), "hello");
    }

    #[test]
    fn test_append_char() {
        let mut sb = new_string_builder_ext();
        append_char(&mut sb, 'x');
        assert_eq!(builder_to_string(&sb), "x");
    }

    #[test]
    fn test_append_line() {
        let mut sb = new_string_builder_ext();
        append_line(&mut sb, "line1");
        assert_eq!(builder_to_string(&sb), "line1\n");
    }

    #[test]
    fn test_builder_len() {
        let mut sb = new_string_builder_ext();
        append_str(&mut sb, "abc");
        assert_eq!(builder_len(&sb), 3);
    }

    #[test]
    fn test_clear() {
        let mut sb = new_string_builder_ext();
        append_str(&mut sb, "stuff");
        builder_clear(&mut sb);
        assert_eq!(builder_len(&sb), 0);
    }

    #[test]
    fn test_capacity() {
        let sb = new_string_builder_ext();
        let _ = builder_capacity(&sb);
    }

    #[test]
    fn test_chained_appends() {
        let mut sb = new_string_builder_ext();
        append_str(&mut sb, "hello");
        append_char(&mut sb, ' ');
        append_str(&mut sb, "world");
        assert_eq!(builder_to_string(&sb), "hello world");
    }

    #[test]
    fn test_multiple_lines() {
        let mut sb = new_string_builder_ext();
        append_line(&mut sb, "a");
        append_line(&mut sb, "b");
        assert_eq!(builder_to_string(&sb), "a\nb\n");
    }

    #[test]
    fn test_empty_to_string() {
        let sb = new_string_builder_ext();
        assert_eq!(builder_to_string(&sb), "");
    }
}