elevator-core 9.0.0

Engine-agnostic elevator simulation library with pluggable dispatch strategies
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

//! Tests that verify event payloads contain correct data.

use crate::components::RiderPhase;
use crate::dispatch::scan::ScanDispatch;
use crate::events::Event;
use crate::sim::Simulation;
use crate::stop::StopId;
use crate::tests::helpers::default_config;

#[test]
fn rider_boarded_event_has_correct_elevator() {
    let config = default_config();
    let mut sim = Simulation::new(&config, ScanDispatch::new()).unwrap();
    let rider = sim.spawn_rider(StopId(0), StopId(2), 70.0).unwrap();

    // Run until we get a RiderBoarded event.
    let mut boarded_event = None;
    for _ in 0..500 {
        sim.step();
        let events = sim.drain_events();
        for e in &events {
            if let Event::RiderBoarded {
                rider: r, elevator, ..
            } = e
                && *r == rider
            {
                boarded_event = Some(*elevator);
            }
        }
        if boarded_event.is_some() {
            break;
        }
    }

    let elevator_id = boarded_event.expect("should have received RiderBoarded event");

    // Verify the rider is riding (or has already ridden) this elevator.
    // By the time we drain the event the rider may have progressed past Riding.
    let rider_data = sim.world().rider(rider).expect("rider should exist");
    let phase_ok = matches!(
        rider_data.phase,
        RiderPhase::Boarding(e) | RiderPhase::Riding(e) | RiderPhase::Exiting(e) if e == elevator_id
    ) || rider_data.phase == RiderPhase::Arrived;
    assert!(
        phase_ok,
        "rider should be boarding/riding/exiting/arrived, got {:?}",
        rider_data.phase,
    );
}

#[test]
fn rider_exited_event_has_correct_stop() {
    let config = default_config();
    let mut sim = Simulation::new(&config, ScanDispatch::new()).unwrap();
    let _rider = sim.spawn_rider(StopId(0), StopId(2), 70.0).unwrap();

    // Run until we get a RiderExited event.
    let mut exited_event = None;
    for _ in 0..2000 {
        sim.step();
        let events = sim.drain_events();
        for e in &events {
            if let Event::RiderExited { stop, .. } = e {
                exited_event = Some(*stop);
            }
        }
        if exited_event.is_some() {
            break;
        }
    }

    let stop_id = exited_event.expect("should have received RiderExited event");

    // Verify the stop entity actually exists.
    let stop = sim.world().stop(stop_id);
    assert!(stop.is_some(), "exited stop entity should exist");
}

/// Extract the tick from an event, if it has one.
fn event_tick(e: &Event) -> Option<u64> {
    #[allow(unreachable_patterns)]
    match e {
        Event::ElevatorDeparted { tick, .. }
        | Event::ElevatorArrived { tick, .. }
        | Event::DoorOpened { tick, .. }
        | Event::DoorClosed { tick, .. }
        | Event::PassingFloor { tick, .. }
        | Event::RiderSpawned { tick, .. }
        | Event::RiderBoarded { tick, .. }
        | Event::RiderExited { tick, .. }
        | Event::RiderRejected { tick, .. }
        | Event::RiderAbandoned { tick, .. }
        | Event::RiderEjected { tick, .. }
        | Event::ElevatorAssigned { tick, .. }
        | Event::StopAdded { tick, .. }
        | Event::ElevatorAdded { tick, .. }
        | Event::EntityDisabled { tick, .. }
        | Event::EntityEnabled { tick, .. }
        | Event::RouteInvalidated { tick, .. }
        | Event::RiderRerouted { tick, .. } => Some(*tick),
        _ => None,
    }
}

#[test]
fn event_ticks_are_monotonically_increasing() {
    let config = default_config();
    let mut sim = Simulation::new(&config, ScanDispatch::new()).unwrap();

    // Spawn riders to generate events.
    for _ in 0..3 {
        sim.spawn_rider(StopId(0), StopId(2), 70.0).unwrap();
    }

    let mut last_tick = 0u64;
    for _ in 0..500 {
        sim.step();
        let events = sim.drain_events();
        for e in &events {
            if let Some(tick) = event_tick(e) {
                assert!(
                    tick >= last_tick,
                    "event tick {tick} should be >= last tick {last_tick}"
                );
                last_tick = tick;
            }
        }
    }
}