wynd 0.9.4

A simple websocket library for Rust.
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

#[cfg(test)]
mod tests {
    use crate::types::WyndError;

    #[test]
    fn test_wynd_error_new() {
        let error_message = "Something went wrong".to_string();
        let error = WyndError::new(error_message.clone());

        assert_eq!(&*error, error_message);
        assert_eq!(&*error, "Something went wrong"); // Test Deref
    }

    #[test]
    fn test_wynd_error_new_empty() {
        let error = WyndError::new(String::new());

        assert_eq!(&*error, "");
    }

    #[test]
    fn test_wynd_error_new_special_characters() {
        let error_message = "Error: 日本語 with émojis 🚀 and newlines\n\ttabs".to_string();
        let error = WyndError::new(error_message.clone());

        assert_eq!(&*error, "Error: 日本語 with émojis 🚀 and newlines\n\ttabs");
    }

    #[test]
    fn test_wynd_error_deref() {
        let error_message = "Connection failed".to_string();
        let error = WyndError::new(error_message);

        // Test direct deref
        let deref_result: &str = &*error;
        assert_eq!(deref_result, "Connection failed");

        // Test that we can use string methods through deref
        assert_eq!(error.len(), 17);
        assert!(error.contains("failed"));
        assert!(error.starts_with("Connection"));
        assert!(error.ends_with("failed"));
    }

    #[test]
    fn test_wynd_error_deref_coercion() {
        let error = WyndError::new("Test error".to_string());

        // Test that we can pass WyndError where &str is expected
        fn takes_str(s: &str) -> usize {
            s.len()
        }

        assert_eq!(takes_str(&error), 10);

        // Test with string slice methods
        let uppercase = error.to_uppercase();
        assert_eq!(uppercase, "TEST ERROR");

        let lowercase = error.to_lowercase();
        assert_eq!(lowercase, "test error");
    }

    #[test]
    fn test_wynd_error_equality_and_display() {
        let error1 = WyndError::new("Same message".to_string());
        let error2 = WyndError::new("Same message".to_string());
        let error3 = WyndError::new("Different message".to_string());

        // Test that errors with same message have same content
        assert_eq!(&*error1, &*error2);
        assert_ne!(&*error1, &*error3);

        // Test Display equality
        assert_eq!(format!("{}", error1), format!("{}", error2));
        assert_ne!(format!("{}", error1), format!("{}", error3));
    }

    #[test]
    fn test_wynd_error_with_long_message() {
        let long_message = "A".repeat(10000);
        let error = WyndError::new(long_message.clone());

        assert_eq!(error.len(), 10000);
        assert_eq!(&*error, long_message);
        assert_eq!(format!("{}", error), long_message);
    }

    #[test]
    fn test_wynd_error_thread_safety() {
        use std::sync::Arc;
        use std::thread;

        let error = Arc::new(WyndError::new("Thread safe error".to_string()));
        let error_clone = Arc::clone(&error);

        let handle = thread::spawn(move || format!("{}", error_clone));

        let result = handle.join().unwrap();
        assert_eq!(result, "Thread safe error");
        assert_eq!(format!("{}", error), "Thread safe error");
    }

    #[test]
    fn test_wynd_error_pattern_matching() {
        let error = WyndError::new("Pattern test".to_string());

        // Test pattern matching on the dereferenced string
        match &*error {
            "Pattern test" => assert!(true),
            _ => unreachable!("Pattern matching failed"),
        }

        // Test with starts_with pattern
        match &*error {
            s if s.starts_with("Pattern") => assert!(true),
            _ => unreachable!("Pattern prefix matching failed"),
        }
    }
}