sim-lib-stream-host 0.1.4

Host-device stream backend substrate for SIM streams.
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

use sim_kernel::Symbol;

use crate::{
    DevicePlacement, DeviceProfile, DeviceSite, DeviceSiteLocality, GlassesAdapterKind,
    GlassesPlacementError, PlacementError, resolve_glasses_placement,
};

#[test]
fn glasses_route_placements_keep_adapters_edge_local() {
    let cases = [
        (
            "direct-linux",
            DeviceSiteLocality::HostLocal,
            GlassesAdapterKind::Reprojector,
        ),
        (
            "android-usb",
            DeviceSiteLocality::HostLocal,
            GlassesAdapterKind::Reprojector,
        ),
        (
            "neckband-local",
            DeviceSiteLocality::EdgeLocal,
            GlassesAdapterKind::Reprojector,
        ),
        (
            "neckband-relay",
            DeviceSiteLocality::Remote,
            GlassesAdapterKind::Reprojector,
        ),
        (
            "mobile-dock-display",
            DeviceSiteLocality::HostLocal,
            GlassesAdapterKind::Mirror,
        ),
        (
            "ble-direct",
            DeviceSiteLocality::HostLocal,
            GlassesAdapterKind::Glance,
        ),
        (
            "web-bluetooth",
            DeviceSiteLocality::HostLocal,
            GlassesAdapterKind::Glance,
        ),
        (
            "phone-relay",
            DeviceSiteLocality::Remote,
            GlassesAdapterKind::Glance,
        ),
        (
            "controller-hid",
            DeviceSiteLocality::HostLocal,
            GlassesAdapterKind::ControllerIntent,
        ),
    ];

    for (route, encoder_locality, adapter) in cases {
        let plan = resolve_glasses_placement(
            Symbol::qualified("device/route", route),
            DeviceProfile::modeled_edge(),
        )
        .expect("valid glasses placement");

        assert_eq!(plan.route.name.as_ref(), route);
        assert_eq!(plan.adapter, adapter);
        assert_eq!(plan.placement.encoder.locality, encoder_locality);
        assert_eq!(
            plan.placement.adapter.locality,
            DeviceSiteLocality::EdgeLocal
        );
        assert_eq!(plan.placement.validate(), Ok(()));
    }
}

#[test]
fn glasses_placement_rejects_unknown_route() {
    let route = Symbol::qualified("device/route", "vendor-cloud");
    assert_eq!(
        resolve_glasses_placement(route.clone(), DeviceProfile::modeled_edge()),
        Err(GlassesPlacementError::UnknownRoute(route))
    );
}

#[test]
fn glasses_placement_rejects_non_edge_adapter() {
    let profile = DeviceProfile::modeled_edge();
    let codec = Symbol::qualified("codec", "scene-spatial");
    let placement = DevicePlacement::new(
        DeviceSite::host_local(
            Symbol::qualified("device/site", "glasses-encoder"),
            profile.clone(),
            codec.clone(),
        ),
        DeviceSite::remote(
            Symbol::qualified("device/site", "glasses-reprojector"),
            profile,
            codec,
        ),
    );

    assert_eq!(
        placement.validate(),
        Err(PlacementError::AdapterMustBeEdgeLocal)
    );
}