rustate 0.2.0

A Rust implementation of statecharts with model-based testing support
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

pub mod checker;
pub mod generator;
pub mod runner;

pub use checker::{ModelChecker, Property, PropertyType, VerificationResult};
pub use generator::{TestCase, TestGenerator};
pub use runner::{CoverageReport, TestResult, TestResults, TestRunner};

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{Machine, MachineBuilder, State, Transition};

    // テスト用の簡単な状態マシンを作成
    fn create_test_machine() -> Machine {
        // 状態の作成
        let green = State::new("green");
        let yellow = State::new("yellow");
        let red = State::new("red");

        // 遷移の作成
        let green_to_yellow = Transition::new("green", "TIMER", "yellow");
        let yellow_to_red = Transition::new("yellow", "TIMER", "red");
        let red_to_green = Transition::new("red", "TIMER", "green");

        // マシンの構築
        MachineBuilder::new("trafficLight")
            .state(green)
            .state(yellow)
            .state(red)
            .initial("green")
            .transition(green_to_yellow)
            .transition(yellow_to_red)
            .transition(red_to_green)
            .build()
            .unwrap()
    }

    #[test]
    fn test_generator_all_states() {
        let machine = create_test_machine();
        let mut generator = TestGenerator::new(&machine);

        let test_cases = generator.generate_all_states();

        // 3つの状態があるはず
        assert_eq!(test_cases.len(), 3);
    }

    #[test]
    fn test_generator_all_transitions() {
        let machine = create_test_machine();
        let mut generator = TestGenerator::new(&machine);

        let test_cases = generator.generate_all_transitions();

        // 3つの遷移があるはず
        assert_eq!(test_cases.len(), 3);
    }

    #[test]
    fn test_runner_execute_test() {
        let machine = create_test_machine();
        let mut runner = TestRunner::new(&machine);

        // グリーンからイエローへの遷移をテスト
        let test_case = TestCase {
            name: "Green to Yellow".to_string(),
            initial_state: "green".to_string(),
            events: vec![crate::Event::new("TIMER")],
            expected_state: "yellow".to_string(),
        };

        let result = runner.run_test(&test_case);

        // テストは成功するはず
        assert!(result.success);
        assert_eq!(result.actual_state, "yellow");
    }

    #[test]
    fn test_model_checker_reachability() {
        let machine = create_test_machine();
        let mut checker = ModelChecker::new(&machine);

        // 到達可能性プロパティをチェック
        let property = Property {
            name: "Can reach red".to_string(),
            property_type: PropertyType::Reachability,
            target_states: vec!["red".to_string()],
            description: None,
        };

        let result = checker.verify_property(&property);

        // redは到達可能なので、プロパティは満たされるはず
        assert!(result.satisfied);
    }

    #[test]
    fn test_model_checker_safety() {
        let machine = create_test_machine();
        let mut checker = ModelChecker::new(&machine);

        // 安全性プロパティをチェック
        let property = Property {
            name: "Never reach invalid state".to_string(),
            property_type: PropertyType::Safety,
            target_states: vec!["invalid".to_string()],
            description: None,
        };

        let result = checker.verify_property(&property);

        // invalidは存在しないので到達不可能、プロパティは満たされるはず
        assert!(result.satisfied);
    }
}