sim-run-core 0.2.0

Core command entry API for the SIM bootloader.
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

use std::sync::Arc;

use sim_kernel::{Cx, DefaultFactory, NoopEvalPolicy, Symbol};

use crate::{
    DeviceConsentPolicy, DeviceHostSpec, DeviceHostStalePolicy, DevicePlacement, DeviceProfile,
    DeviceProviderKind, DeviceRateClass, DeviceSite, RouteArg, compose_device_host,
};

fn test_cx() -> Cx {
    Cx::new(Arc::new(NoopEvalPolicy), Arc::new(DefaultFactory))
}

fn reference_placement(profile: &DeviceProfile) -> DevicePlacement {
    let codec = Symbol::qualified("codec", "surface-device");
    DevicePlacement::new(
        DeviceSite::remote(
            Symbol::qualified("device/site", "host-encoder"),
            profile.clone(),
            codec.clone(),
        ),
        DeviceSite::edge_local(
            Symbol::qualified("device/site", "edge-adapter"),
            profile.clone(),
            codec,
        ),
    )
}

#[test]
fn compose_reference_device_headless() {
    let mut cx = test_cx();
    let profile = DeviceProfile::modeled_edge();
    let placement = reference_placement(&profile);
    let spec = DeviceHostSpec::new(
        profile.clone(),
        RouteArg::headless(),
        placement.clone(),
        DeviceHostStalePolicy::HoldLast,
        DeviceConsentPolicy::Headless,
    );

    let mut session = compose_device_host(&mut cx, spec).expect("compose device host");

    assert!(session.is_live());
    assert_eq!(session.provider_kind(), DeviceProviderKind::Stub);
    assert_eq!(session.profile(), &profile);
    assert_eq!(session.device_session().profile(), &profile);
    assert_eq!(session.route(), &RouteArg::headless());
    assert_eq!(session.placement(), &placement);
    assert_eq!(
        session.adapter_loop().rate_class(),
        DeviceRateClass::Surface
    );
    assert_eq!(session.adapter_loop().interval_ms(), 50);
    assert_eq!(session.adapter_loop().sequence(), 0);
    assert_eq!(session.hub_join().route(), &RouteArg::headless());
    assert_eq!(session.hub_join().adapter_site(), &placement.adapter.symbol);

    let tick = session.adapter_loop_mut().next_tick();

    assert_eq!(tick.sequence(), 1);
    assert_eq!(tick.interval_ms(), 50);
    assert_eq!(session.adapter_loop().sequence(), 1);
}