cranpose-testing 0.9.8

Composition, semantics, accessibility, and robot test utilities for Cranpose
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

//! A node's offset moves it on the next layout whenever the offset or the
//! layout direction an offset follows changes, though nothing else about
//! the node's modifiers did.

use cranpose_core::MutableState;
use cranpose_testing::{ComposeTestRule, PlacedSemanticsNode};
use cranpose_ui::{Box, BoxSpec, LayoutDirection, Modifier, ProvideLayoutDirection, Size};

fn tagged(modifier: Modifier) -> Modifier {
    modifier.semantics(|config| {
        config.content_description = Some("moved".to_string());
    })
}

fn left_of_moved(rule: &mut ComposeTestRule) -> f32 {
    let root: PlacedSemanticsNode = rule
        .placed_semantics(Size::new(200.0, 100.0))
        .expect("the content lays out")
        .expect("the content places something");
    root.flatten()
        .into_iter()
        .find(|node| node.label.as_deref() == Some("moved"))
        .expect("the moved box is placed")
        .layout_bounds
        .x
}

#[test]
fn a_changed_offset_moves_the_node() {
    let mut rule = ComposeTestRule::new();
    let x = MutableState::with_runtime(10.0f32, rule.runtime_handle());
    rule.set_content(move || {
        Box(
            Modifier::empty().size(Size::new(200.0, 100.0)),
            BoxSpec::default(),
            move || {
                Box(
                    tagged(
                        Modifier::empty()
                            .offset(x.get(), 0.0)
                            .size(Size::new(20.0, 20.0)),
                    ),
                    BoxSpec::default(),
                    || {},
                );
            },
        );
    })
    .expect("the content composes");
    assert_eq!(left_of_moved(&mut rule), 10.0);
    x.set(35.0);
    assert_eq!(
        left_of_moved(&mut rule),
        35.0,
        "the node follows its new offset"
    );
}

#[test]
fn an_offset_follows_a_changed_layout_direction() {
    let mut rule = ComposeTestRule::new();
    let direction = MutableState::with_runtime(LayoutDirection::Ltr, rule.runtime_handle());
    rule.set_content(move || {
        ProvideLayoutDirection(direction.get(), || {
            Box(
                Modifier::empty().size(Size::new(200.0, 100.0)),
                BoxSpec::default(),
                || {
                    Box(
                        tagged(
                            Modifier::empty()
                                .offset(10.0, 0.0)
                                .size(Size::new(20.0, 20.0)),
                        ),
                        BoxSpec::default(),
                        || {},
                    );
                },
            );
        });
    })
    .expect("the content composes");
    let ltr = left_of_moved(&mut rule);
    direction.set(LayoutDirection::Rtl);
    let rtl = left_of_moved(&mut rule);
    assert_eq!(
        ltr, 10.0,
        "left to right, the offset moves the box right of the start"
    );
    assert_eq!(
        rtl,
        200.0 - 20.0 - 10.0,
        "right to left, it moves it left of the end"
    );
}