use std::time::{Duration, Instant};
use super::{Harness, node_at};
use crate::{Color, Easing, Row, Stack, Style, Text, Transition, Window, advance_animations};
fn revisions(window: &Window) -> [u64; 3] {
let view = window.view();
let root = view.root();
[&[][..], &[0], &[0, 0]].map(|path| node_at(root, path).revision())
}
#[test]
fn a_nodes_own_opacity_and_transform_leave_its_revision_and_its_childrens() {
let mut h = Harness::new();
let opacity = h.cx.signal(0.5_f32);
let scale = h.cx.signal(1.0_f32);
let stack = Stack::new()
.style(move || Style::new().opacity(opacity.get()).scale(scale.get()))
.child(
Row::new().style(
Style::new()
.width(20.0)
.height(20.0)
.background(Color::rgb(9, 9, 9)),
),
);
let window = h.window(h.panel().child(stack), 100.0, 40.0);
let [root, own, child] = revisions(&window);
opacity.set(0.25);
h.frame(&window);
let [after_root, after_own, after_child] = revisions(&window);
assert_ne!(after_root, root, "a change inside the window");
assert_eq!((after_own, after_child), (own, child));
scale.set(0.8);
h.frame(&window);
let [moved_root, moved_own, moved_child] = revisions(&window);
assert_ne!(moved_root, after_root);
assert_eq!((moved_own, moved_child), (own, child));
}
#[test]
fn a_change_inside_moves_every_revision_around_it() {
let mut h = Harness::new();
let dark = h.cx.signal(true);
let wide = h.cx.signal(false);
let stack = Stack::new()
.style(Style::new().opacity(0.5))
.child(Row::new().style(move || {
let shade = if dark.get() { 9 } else { 200 };
Style::new()
.width(if wide.get() { 40.0 } else { 20.0 })
.height(20.0)
.background(Color::rgb(shade, shade, shade))
}));
let window = h.window(h.panel().child(stack), 100.0, 40.0);
let before = revisions(&window);
dark.set(false);
h.frame(&window);
let painted = revisions(&window);
for (after, before) in painted.iter().zip(before) {
assert_ne!(*after, before, "a new background");
}
wide.set(true);
h.frame(&window);
for (after, before) in revisions(&window).iter().zip(painted) {
assert_ne!(*after, before, "a new size");
}
}
#[test]
fn a_color_text_inherits_from_outside_moves_the_revisions_inside() {
let mut h = Harness::new();
let red = h.cx.signal(false);
let outer = Row::new()
.style(move || Style::new().color(Color::rgb(if red.get() { 255 } else { 0 }, 0, 0)))
.child(
Stack::new()
.style(Style::new().opacity(0.5))
.child(Text::new("ink")),
);
let window = h.window(h.panel().child(outer), 100.0, 40.0);
let layered = |window: &Window| {
let view = window.view();
let root = view.root();
(
node_at(root, &[0, 0]).revision(),
node_at(root, &[0, 0, 0]).revision(),
)
};
let before = layered(&window);
red.set(true);
h.frame(&window);
let after = layered(&window);
assert_ne!(after.0, before.0);
assert_ne!(after.1, before.1);
}
#[test]
fn a_hidden_or_reordered_child_moves_its_parents_revision() {
let mut h = Harness::new();
let shown = h.cx.signal(true);
let order = h.cx.signal(vec![1, 2]);
let boxed = |shade: u8| {
Row::new().style(
Style::new()
.width(20.0)
.height(20.0)
.background(Color::rgb(shade, shade, shade)),
)
};
let stack = Stack::new()
.style(Style::new().opacity(0.5))
.child(boxed(9).visible(move || shown.get()))
.children_keyed(
move || order.get(),
|n| *n,
move |_, n| boxed(n.get_untracked() as u8 * 50),
);
let window = h.window(h.panel().child(stack), 100.0, 40.0);
let stack_revision = |window: &Window| node_at(window.view().root(), &[0]).revision();
let before = stack_revision(&window);
shown.set(false);
h.frame(&window);
let hidden = stack_revision(&window);
assert_ne!(hidden, before);
order.set(vec![2, 1]);
h.frame(&window);
assert_ne!(stack_revision(&window), hidden);
}
#[test]
fn a_fading_opacity_leaves_the_revision_and_a_fading_color_moves_it() {
let mut h = Harness::new();
let faded = h.cx.signal(false);
let stack = Stack::new()
.style(move || {
let (opacity, shade) = if faded.get() { (0.2, 200) } else { (0.9, 9) };
Style::new()
.opacity(opacity)
.background(Color::rgb(shade, shade, shade))
.width(20.0)
.height(20.0)
.transition(Transition::new(100).easing(Easing::Linear))
})
.child(Row::new().style(Style::new().width(10.0).height(10.0)));
let window = h.window(h.panel().child(stack), 100.0, 40.0);
let own = |window: &Window| node_at(window.view().root(), &[0]).revision();
let before = own(&window);
faded.set(true);
h.frame(&window);
let start = Instant::now();
advance_animations(start);
advance_animations(start + Duration::from_millis(50));
h.frame(&window);
assert_ne!(own(&window), before, "the background fades too");
}
#[test]
fn a_fade_of_opacity_alone_leaves_the_revision() {
let mut h = Harness::new();
let faded = h.cx.signal(false);
let stack = Stack::new()
.style(move || {
Style::new()
.opacity(if faded.get() { 0.2 } else { 0.9 })
.background(Color::rgb(9, 9, 9))
.width(20.0)
.height(20.0)
.transition(Transition::new(100).easing(Easing::Linear))
})
.child(Row::new().style(Style::new().width(10.0).height(10.0)));
let window = h.window(h.panel().child(stack), 100.0, 40.0);
let own = |window: &Window| node_at(window.view().root(), &[0]).revision();
let before = own(&window);
faded.set(true);
h.frame(&window);
let start = Instant::now();
advance_animations(start);
advance_animations(start + Duration::from_millis(50));
h.frame(&window);
let opacity = node_at(window.view().root(), &[0]).style().opacity;
assert!(
opacity.is_some_and(|opacity| (opacity - 0.55).abs() < 1e-4),
"{opacity:?}"
);
assert_eq!(own(&window), before);
}
#[test]
fn a_layered_node_moved_by_its_sibling_gets_a_new_revision() {
let mut h = Harness::new();
let wide = h.cx.signal(false);
let row = Row::new()
.child(Row::new().style(move || {
Style::new()
.width(if wide.get() { 40.0 } else { 20.0 })
.height(20.0)
}))
.child(
Stack::new()
.style(Style::new().opacity(0.5))
.child(Row::new().style(Style::new().width(20.0).height(20.0))),
);
let window = h.window(h.panel().child(row), 100.0, 40.0);
let layered = |window: &Window| {
let view = window.view();
let root = view.root();
(
node_at(root, &[0, 1]).revision(),
node_at(root, &[0, 1, 0]).revision(),
)
};
let before = layered(&window);
wide.set(true);
h.frame(&window);
let after = layered(&window);
assert_ne!(after.0, before.0, "its layer would be drawn where it was");
assert_ne!(after.1, before.1);
}
#[test]
fn text_shaped_again_for_an_inherited_style_moves_the_revisions_around_it() {
use crate::TextAlign;
let mut h = Harness::new();
let end = h.cx.signal(false);
let outer = Stack::new()
.style(move || {
let align = if end.get() {
TextAlign::End
} else {
TextAlign::Start
};
Style::new().width(200.0).height(40.0).text_align(align)
})
.child(
Stack::new()
.style(Style::new().width(200.0).height(40.0).opacity(0.5))
.child(Text::new("ab").style(Style::new().width(200.0).height(30.0))),
);
let window = h.window(h.panel().child(outer), 200.0, 40.0);
let layered = |window: &Window| {
let view = window.view();
let root = view.root();
(
node_at(root, &[0, 0]).revision(),
node_at(root, &[0, 0, 0]).revision(),
)
};
let before = layered(&window);
end.set(true);
h.frame(&window);
let after = layered(&window);
assert_ne!(after.0, before.0, "its layer holds the old glyphs");
assert_ne!(after.1, before.1);
}