switchy 0.2.0

Switchy package
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

//! Test switchy::unsync::join! access pattern

#[cfg(feature = "async")]
#[switchy::unsync::test(real_time)]
async fn unsync_join_works() {
    use std::time::Duration;

    let (a, b, c) = switchy::unsync::join!(
        async {
            switchy::unsync::time::sleep(Duration::from_millis(5)).await;
            1
        },
        async {
            switchy::unsync::time::sleep(Duration::from_millis(10)).await;
            2
        },
        async {
            switchy::unsync::time::sleep(Duration::from_millis(15)).await;
            3
        }
    );

    assert_eq!(a + b + c, 6);
}

#[cfg(feature = "async")]
#[switchy::unsync::test(real_time)]
async fn unsync_try_join_error_handling() {
    let result = switchy::unsync::try_join!(async { Ok::<_, String>(42) }, async {
        Err::<i32, _>("error".to_string())
    });

    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "error".to_string());
}

#[cfg(feature = "async")]
#[switchy::unsync::test(real_time)]
async fn unsync_join_concurrent_execution() {
    use std::sync::Arc;
    use std::sync::atomic::{AtomicU32, Ordering};
    use std::time::Duration;

    let counter = Arc::new(AtomicU32::new(0));
    let c1 = counter.clone();
    let c2 = counter.clone();

    let (val1, val2) = switchy::unsync::join!(
        async move {
            c1.fetch_add(1, Ordering::SeqCst);
            switchy::unsync::time::sleep(Duration::from_millis(10)).await;
            c1.load(Ordering::SeqCst)
        },
        async move {
            c2.fetch_add(1, Ordering::SeqCst);
            switchy::unsync::time::sleep(Duration::from_millis(10)).await;
            c2.load(Ordering::SeqCst)
        }
    );

    // Both should see the counter at 2 since they run concurrently
    assert_eq!(val1, 2);
    assert_eq!(val2, 2);
}

#[cfg(feature = "async")]
#[switchy::unsync::test(real_time)]
async fn unsync_try_join_success() {
    let result = switchy::unsync::try_join!(
        async { Ok::<_, &str>(1) },
        async { Ok::<_, &str>("hello") },
        async { Ok::<_, &str>(true) }
    );

    assert!(result.is_ok());
    let (a, b, c) = result.unwrap();
    assert_eq!(a, 1);
    assert_eq!(b, "hello");
    assert!(c);
}

#[cfg(feature = "async")]
#[switchy::unsync::test(real_time)]
async fn unsync_join_with_tasks() {
    // Test that switchy::unsync::join! correctly awaits spawned tasks
    let (result1, result2) = switchy::unsync::join!(
        switchy::unsync::task::spawn(async { 42 }),
        switchy::unsync::task::spawn(async { "spawned" })
    );

    assert_eq!(result1.unwrap(), 42);
    assert_eq!(result2.unwrap(), "spawned");
}

#[cfg(feature = "async")]
#[switchy::unsync::test(real_time)]
async fn unsync_join_empty() {
    // Test edge case: join! with no arguments
    switchy::unsync::join!();
}

#[cfg(feature = "async")]
#[switchy::unsync::test(real_time)]
async fn unsync_try_join_with_mixed_results() {
    // Test try_join! with mix of Ok and Err that all succeed
    let result = switchy::unsync::try_join!(
        async { Ok::<i32, String>(1) },
        async { Ok::<i32, String>(2) },
        async { Ok::<i32, String>(3) }
    );

    assert_eq!(result.unwrap(), (1, 2, 3));

    // Test try_join! where middle future fails
    let result = switchy::unsync::try_join!(
        async { Ok::<i32, String>(1) },
        async { Err::<i32, String>("middle failure".to_string()) },
        async { Ok::<i32, String>(3) }
    );

    assert_eq!(result.unwrap_err(), "middle failure");
}