196 lines
7.9 KiB
Rust
196 lines
7.9 KiB
Rust
use midra_layout::device::Snapshot;
|
|
use serde_json::{Value, json};
|
|
fn fixture() -> (Value, Value) {
|
|
let layer = json!({"position":{"pp":{"posH":1436,"posV":540}},"size":{"pp":{"sizeH":967,"sizeV":544}},"source":{"pp":{"input":"INPUT_4"}},"crop":{"pp":{"left":0,"right":0,"top":0,"bottom":0}},"mask":{"pp":{"left":0,"right":0,"top":0,"bottom":0}}});
|
|
let screen = json!({
|
|
"canvas": {"status": {"size": {"pp": {"sizeH": 1920, "sizeV": 1080}}}},
|
|
"presetList": {"items": {"UP": {"liveLayerList": {"items": {"1": layer}}}}}
|
|
});
|
|
let raw = json!({"device": {
|
|
"preconfig":{"status":{"stateList":{"items":{"CURRENT":{"screenList":{"items":{"2":{"pp":{"layerCount":2}}}}}}}}},
|
|
"transition": {"screenList": {"items": {"2": {"status": {"pp": {"transition": "AT_DOWN"}}}}}},
|
|
"screenList": {"items": {"2": screen}}
|
|
}});
|
|
(
|
|
json!({"type":"Eikos 4K","version":{"major":3,"minor":3,"patch":10}}),
|
|
raw,
|
|
)
|
|
}
|
|
#[test]
|
|
fn preview_read_retains_half_pixels_and_maps_source_label() {
|
|
let (identity, raw) = fixture();
|
|
let snapshot = Snapshot::parse(&identity, &raw).unwrap();
|
|
assert_eq!(snapshot.identity, "Eikos 4K · firmware 3.3.10");
|
|
let screen = &snapshot.screens[0];
|
|
assert_eq!(screen.preview_bank, "UP");
|
|
let doc = screen.import(&[0]).unwrap();
|
|
assert_eq!(doc.shapes[0].geometry.x, 952.5);
|
|
assert_eq!(doc.shapes[0].geometry.y, 268.0);
|
|
assert!(doc.shapes[0].id.contains("INPUT_4"));
|
|
assert!(screen.import(&[]).is_err());
|
|
assert!(screen.import(&[0, 0]).is_err());
|
|
assert!(screen.import(&[9]).is_err());
|
|
}
|
|
#[test]
|
|
fn reject_transition_and_missing_preview_without_falling_back_to_program() {
|
|
let (identity, mut raw) = fixture();
|
|
let state = "/device/transition/screenList/items/2/status/pp/transition";
|
|
*raw.pointer_mut(state).unwrap() = json!("EFFECT_FROM_DOWN");
|
|
assert!(
|
|
Snapshot::parse(&identity, &raw)
|
|
.unwrap_err()
|
|
.contains("transitioning")
|
|
);
|
|
*raw.pointer_mut(state).unwrap() = json!("AT_UP");
|
|
assert!(Snapshot::parse(&identity, &raw).is_err());
|
|
let up = raw
|
|
.pointer("/device/screenList/items/2/presetList/items/UP")
|
|
.unwrap()
|
|
.clone();
|
|
raw["device"]["screenList"]["items"]["2"]["presetList"]["items"]["DOWN"] = up;
|
|
assert_eq!(
|
|
Snapshot::parse(&identity, &raw).unwrap().screens[0].preview_bank,
|
|
"DOWN"
|
|
);
|
|
}
|
|
#[test]
|
|
fn unsupported_framing_is_visible_but_not_importable() {
|
|
let (identity, mut raw) = fixture();
|
|
raw["device"]["screenList"]["items"]["2"]["presetList"]["items"]["UP"]["liveLayerList"]["items"]
|
|
["1"]["crop"]["pp"]["left"] = json!(18350);
|
|
let s = Snapshot::parse(&identity, &raw).unwrap();
|
|
assert_eq!(s.screens[0].layers.len(), 1);
|
|
assert!(s.screens[0].import(&[0]).unwrap_err().contains("crop"));
|
|
}
|
|
#[test]
|
|
fn malformed_device_state_fails_before_import() {
|
|
let (mut identity, mut raw) = fixture();
|
|
identity["type"] = json!("different device");
|
|
assert!(Snapshot::parse(&identity, &raw).is_err());
|
|
identity["type"] = json!("Eikos 4K");
|
|
raw["device"]["screenList"]["items"]["2"]["canvas"]["status"]["size"]["pp"]["sizeH"] =
|
|
json!(1920.5);
|
|
assert!(Snapshot::parse(&identity, &raw).is_err());
|
|
assert!(midra_layout::device::fetch("http://localhost/").is_err());
|
|
}
|
|
#[test]
|
|
fn disabled_screen_slots_are_ignored() {
|
|
let (identity, mut raw) = fixture();
|
|
let mut disabled = raw["device"]["screenList"]["items"]["2"].clone();
|
|
disabled["canvas"]["status"]["size"]["pp"] = json!({"sizeH":0,"sizeV":0});
|
|
raw["device"]["screenList"]["items"]["3"] = disabled;
|
|
raw["device"]["transition"]["screenList"]["items"]["3"] =
|
|
json!({"status":{"pp":{"transition":"AT_DOWN"}}});
|
|
assert_eq!(Snapshot::parse(&identity, &raw).unwrap().screens.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn mapped_import_ignores_selection_and_undoes_new_layers_together() {
|
|
let mut layout = midra_layout::Layout::default();
|
|
layout.select(None);
|
|
let before = layout.layers().clone();
|
|
let id = layout.layer_info(0).id;
|
|
let geometry = midra_layout::Geometry {
|
|
x: 12.5,
|
|
y: 27.0,
|
|
width: 945.0,
|
|
height: 531.58,
|
|
};
|
|
layout
|
|
.import_mapped_layers(&[(Some(id), geometry), (None, geometry), (None, geometry)])
|
|
.unwrap();
|
|
assert_eq!(layout.layers().len(), 4);
|
|
assert_eq!(layout.layers()[0], geometry);
|
|
let new_id = layout.layer_info(3).id;
|
|
layout.undo();
|
|
assert_eq!(*layout.layers(), before);
|
|
layout.redo();
|
|
assert_eq!(layout.layers().len(), 4);
|
|
assert_eq!(layout.layer_info(3).id, new_id);
|
|
let added = layout.add_layer().unwrap();
|
|
assert!(layout.layer_info(added).id > new_id);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_mapping_never_partially_imports() {
|
|
let mut layout = midra_layout::Layout::default();
|
|
let before = layout.layers().clone();
|
|
let geometry = before[1];
|
|
let id = layout.layer_info(0).id;
|
|
for values in [
|
|
vec![],
|
|
vec![(None, geometry), (Some(999), geometry)],
|
|
vec![(Some(id), geometry), (Some(id), geometry)],
|
|
] {
|
|
assert!(layout.import_mapped_layers(&values).is_err());
|
|
assert_eq!(*layout.layers(), before);
|
|
}
|
|
layout.set_locked(0, true);
|
|
assert!(
|
|
layout
|
|
.import_mapped_layers(&[(None, geometry), (Some(id), geometry)])
|
|
.is_err()
|
|
);
|
|
assert_eq!(*layout.layers(), before);
|
|
layout.set_locked(0, false);
|
|
layout.set_visible(0, false);
|
|
assert!(
|
|
layout
|
|
.import_mapped_layers(&[(Some(id), geometry)])
|
|
.is_err()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn existing_layers_remain_available_without_source_assignment() {
|
|
let (identity, mut raw) = fixture();
|
|
let entries = raw
|
|
.pointer_mut("/device/screenList/items/2/presetList/items/UP/liveLayerList/items")
|
|
.unwrap();
|
|
entries["1"]["status"] = json!({"pp": {"state": "OFF"}});
|
|
entries["2"] = entries["1"].clone();
|
|
entries["2"]["crop"]["pp"]["aspectOverride"] = json!("CENTERED");
|
|
entries["2"]["status"]["pp"]["contentWidth"] = json!(0);
|
|
entries["2"]["status"]["pp"]["contentHeight"] = json!(0);
|
|
for input in [json!("NONE"), json!(""), Value::Null] {
|
|
raw["device"]["screenList"]["items"]["2"]["presetList"]["items"]["UP"]["liveLayerList"]["items"]
|
|
["2"]["source"]["pp"]["input"] = input;
|
|
let snapshot = Snapshot::parse(&identity, &raw).unwrap();
|
|
let screen = &snapshot.screens[0];
|
|
assert_eq!(screen.layers.len(), 2);
|
|
assert!(screen.layers.iter().all(|l| l.unsupported.is_none()));
|
|
assert_eq!(screen.import(&[0, 1]).unwrap().shapes.len(), 2);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn allocation_filters_firmware_slots_independently_of_input_routing() {
|
|
let (identity, mut raw) = fixture();
|
|
let entries = raw
|
|
.pointer_mut("/device/screenList/items/2/presetList/items/UP/liveLayerList/items")
|
|
.unwrap();
|
|
for id in 2..=8 {
|
|
entries[id.to_string()] = entries["1"].clone();
|
|
}
|
|
// Ignore staged NEW configuration and use only the active CURRENT allocation.
|
|
raw["device"]["preconfig"]["status"]["stateList"]["items"]["NEW"] =
|
|
json!({"screenList":{"items":{"2":{"pp":{"layerCount":8}}}}});
|
|
for count in [0, 1, 2] {
|
|
raw["device"]["preconfig"]["status"]["stateList"]["items"]["CURRENT"]["screenList"]["items"]
|
|
["2"]["pp"]["layerCount"] = json!(count);
|
|
let snapshot = Snapshot::parse(&identity, &raw).unwrap();
|
|
assert_eq!(snapshot.screens[0].layers.len(), count);
|
|
assert!(
|
|
snapshot.screens[0]
|
|
.layers
|
|
.iter()
|
|
.all(|l| l.id.parse::<usize>().unwrap() <= count)
|
|
);
|
|
}
|
|
for invalid in [Value::Null, json!(-1), json!(2.5), json!(9)] {
|
|
raw["device"]["preconfig"]["status"]["stateList"]["items"]["CURRENT"]["screenList"]["items"]
|
|
["2"]["pp"]["layerCount"] = invalid;
|
|
assert!(Snapshot::parse(&identity, &raw).is_err());
|
|
}
|
|
}
|