platform-data 2.0.0

Data types and traits for the LinksPlatform
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
136
137
138

use platform_data::Flow;
use std::ops::ControlFlow;

#[test]
fn basic() {
    let mut vec = vec![];

    for i in 0..20 {
        vec.push(i);
        let flow = if i == 10 { Flow::Break } else { Flow::Continue };
        if flow.is_break() {
            break;
        }
    }

    assert_eq!(vec, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
}

#[test]
fn test_flow_continue_with_control_flow() {
    let mut count = 0;
    let _ = (0..5).try_for_each(|_| {
        count += 1;
        Flow::Continue.into_control_flow()
    });
    assert_eq!(count, 5);
}

#[test]
fn test_flow_break_early_with_control_flow() {
    let mut count = 0;
    let _ = (0..100).try_for_each(|_| {
        count += 1;
        Flow::Break.into_control_flow()
    });
    assert_eq!(count, 1); // Should stop after first iteration
}

#[test]
fn test_from_control_flow_continue() {
    // Test conversion from ControlFlow::Continue
    let cf: ControlFlow<i32, ()> = ControlFlow::Continue(());
    let flow: Flow = cf.into();
    assert!(flow.is_continue());
}

#[test]
fn test_from_control_flow_break() {
    // Test conversion from ControlFlow::Break
    let cf: ControlFlow<(), i32> = ControlFlow::Break(());
    let flow: Flow = cf.into();
    assert!(flow.is_break());

    // Verify Break behavior
    let mut count = 0;
    let _ = (0..10).try_for_each(|_| {
        count += 1;
        Flow::Break.into_control_flow()
    });
    assert_eq!(count, 1);
}

#[test]
fn from_control_flow() {
    let continue_flow: Flow = ControlFlow::<(), ()>::Continue(()).into();
    assert!(continue_flow.is_continue());

    let break_flow: Flow = ControlFlow::<(), ()>::Break(()).into();
    assert!(break_flow.is_break());
}

#[test]
fn into_control_flow() {
    let cf: ControlFlow<()> = Flow::Continue.into();
    assert!(matches!(cf, ControlFlow::Continue(())));

    let cf: ControlFlow<()> = Flow::Break.into();
    assert!(matches!(cf, ControlFlow::Break(())));
}

#[test]
fn test_into_control_flow_method() {
    // Test the into_control_flow() method
    let continue_cf = Flow::Continue.into_control_flow();
    assert!(matches!(continue_cf, ControlFlow::Continue(())));

    let break_cf = Flow::Break.into_control_flow();
    assert!(matches!(break_cf, ControlFlow::Break(())));
}

#[test]
fn test_flow_with_iterator() {
    // Test using Flow with iterators via into_control_flow
    let mut collected = vec![];
    let _ = (0..20).try_for_each(|i| {
        collected.push(i);
        if i == 10 {
            Flow::Break.into_control_flow()
        } else {
            Flow::Continue.into_control_flow()
        }
    });
    assert_eq!(collected, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
}

#[test]
fn test_is_continue() {
    assert!(Flow::Continue.is_continue());
    assert!(!Flow::Break.is_continue());
}

#[test]
fn test_is_break() {
    assert!(Flow::Break.is_break());
    assert!(!Flow::Continue.is_break());
}

#[test]
fn test_flow_copy() {
    let flow = Flow::Continue;
    let copied1 = flow;
    let copied2 = flow;
    assert_eq!(flow, copied1);
    assert_eq!(flow, copied2);
}

#[test]
fn test_flow_eq() {
    assert_eq!(Flow::Continue, Flow::Continue);
    assert_eq!(Flow::Break, Flow::Break);
    assert_ne!(Flow::Continue, Flow::Break);
}

#[test]
fn test_flow_debug() {
    assert_eq!(format!("{:?}", Flow::Continue), "Continue");
    assert_eq!(format!("{:?}", Flow::Break), "Break");
}