ash-flare 2.3.3

Fault-tolerant supervision trees for Rust with distributed capabilities inspired by Erlang/OTP
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

use ash_flare::{ChildType, RestartPolicy, RestartStrategy};

#[test]
fn test_child_type_debug() {
    let worker = ChildType::Worker;
    let debug_str = format!("{:?}", worker);
    assert!(debug_str.contains("Worker"));

    let supervisor = ChildType::Supervisor;
    let debug_str = format!("{:?}", supervisor);
    assert!(debug_str.contains("Supervisor"));
}

#[test]
fn test_child_type_clone() {
    let worker = ChildType::Worker;
    let cloned = worker.clone();
    assert_eq!(cloned, ChildType::Worker);
}

#[test]
fn test_child_type_equality() {
    assert_eq!(ChildType::Worker, ChildType::Worker);
    assert_eq!(ChildType::Supervisor, ChildType::Supervisor);
    assert_ne!(ChildType::Worker, ChildType::Supervisor);
}

#[test]
fn test_restart_policy_debug() {
    let permanent = RestartPolicy::Permanent;
    assert!(format!("{:?}", permanent).contains("Permanent"));

    let temporary = RestartPolicy::Temporary;
    assert!(format!("{:?}", temporary).contains("Temporary"));

    let transient = RestartPolicy::Transient;
    assert!(format!("{:?}", transient).contains("Transient"));
}

#[test]
fn test_restart_policy_clone() {
    let policy = RestartPolicy::Permanent;
    let cloned = policy.clone();
    assert_eq!(cloned, RestartPolicy::Permanent);
}

#[test]
fn test_restart_policy_copy() {
    let policy = RestartPolicy::Transient;
    let copied = policy; // Copy trait
    assert_eq!(copied, RestartPolicy::Transient);
    assert_eq!(policy, RestartPolicy::Transient); // Original still valid
}

#[test]
fn test_restart_strategy_debug() {
    let one_for_one = RestartStrategy::OneForOne;
    assert!(format!("{:?}", one_for_one).contains("OneForOne"));

    let one_for_all = RestartStrategy::OneForAll;
    assert!(format!("{:?}", one_for_all).contains("OneForAll"));

    let rest_for_one = RestartStrategy::RestForOne;
    assert!(format!("{:?}", rest_for_one).contains("RestForOne"));
}

#[test]
fn test_restart_strategy_clone() {
    let strategy = RestartStrategy::OneForAll;
    let cloned = strategy.clone();
    assert_eq!(cloned, RestartStrategy::OneForAll);
}

#[test]
fn test_restart_strategy_copy() {
    let strategy = RestartStrategy::RestForOne;
    let copied = strategy; // Copy trait
    assert_eq!(copied, RestartStrategy::RestForOne);
    assert_eq!(strategy, RestartStrategy::RestForOne); // Original still valid
}

#[test]
fn test_restart_policy_default() {
    let default = RestartPolicy::default();
    assert_eq!(default, RestartPolicy::Permanent);
}

#[test]
fn test_restart_strategy_default() {
    let default = RestartStrategy::default();
    assert_eq!(default, RestartStrategy::OneForOne);
}