revue 2.71.1

A Vue-style TUI framework for Rust with CSS styling
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Tests for animation spring module
//!
//! Extracted from src/utils/animation/spring.rs

use revue::utils::animation::Spring;

#[test]
fn test_spring_new() {
    let spring = Spring::new(0.0, 100.0);
    assert_eq!(spring.value(), 0.0);
    assert_eq!(spring.target(), 100.0);
    assert_eq!(spring.velocity(), 0.0);
}

#[test]
fn test_spring_at() {
    let spring = Spring::at(50.0);
    assert_eq!(spring.value(), 50.0);
    assert_eq!(spring.target(), 50.0);
    assert!(spring.is_settled());
}

#[test]
fn test_spring_snappy() {
    let spring = Spring::snappy();
    assert_eq!(spring.value(), 0.0);
    assert_eq!(spring.target(), 0.0);
    // Stiffness and damping are private fields - presets tested via behavior
    assert!(spring.is_settled());
}

#[test]
fn test_spring_gentle() {
    let spring = Spring::gentle();
    assert_eq!(spring.value(), 0.0);
    assert_eq!(spring.target(), 0.0);
    assert!(spring.is_settled());
}

#[test]
fn test_spring_bouncy() {
    let spring = Spring::bouncy();
    assert_eq!(spring.value(), 0.0);
    assert_eq!(spring.target(), 0.0);
    assert!(spring.is_settled());
}

#[test]
fn test_spring_slow() {
    let spring = Spring::slow();
    assert_eq!(spring.value(), 0.0);
    assert_eq!(spring.target(), 0.0);
    assert!(spring.is_settled());
}

#[test]
fn test_spring_set_target() {
    let mut spring = Spring::new(0.0, 100.0);
    spring.set_target(50.0);
    assert_eq!(spring.target(), 50.0);
}

#[test]
fn test_spring_set_value() {
    let mut spring = Spring::new(0.0, 100.0);
    spring.set_value(75.0);
    assert_eq!(spring.value(), 75.0);
    assert_eq!(spring.velocity(), 0.0);
}

#[test]
fn test_spring_is_settled() {
    let spring = Spring::at(50.0);
    assert!(spring.is_settled());
}

#[test]
fn test_spring_is_settled_false() {
    let spring = Spring::new(0.0, 100.0);
    assert!(!spring.is_settled());
}

#[test]
fn test_spring_update_changes_value() {
    let mut spring = Spring::new(0.0, 100.0);
    let value1 = spring.update(0.016);
    let value2 = spring.update(0.016);
    // Spring should move toward target
    assert!(value2 > value1);
    assert!(value2 <= 100.0);
}

#[test]
fn test_spring_tick() {
    let mut spring = Spring::new(0.0, 100.0);
    let value1 = spring.tick();
    let value2 = spring.tick();
    // Spring should move toward target
    assert!(value2 > value1);
}

#[test]
fn test_spring_update_settled() {
    let mut spring = Spring::at(50.0);
    spring.set_target(50.0);
    let value = spring.update(0.016);
    // Already at target
    assert_eq!(value, 50.0);
}

// Removed test_spring_default_fields - it accessed private fields (stiffness, damping, mass, threshold)
// Default values are tested indirectly through behavior tests

#[test]
fn test_spring_velocity_changes() {
    let mut spring = Spring::new(0.0, 100.0);
    let v1 = spring.velocity();
    spring.update(0.016);
    let v2 = spring.velocity();
    // Velocity should change as spring accelerates
    assert_ne!(v1, v2);
}

#[test]
fn test_spring_velocity_toward_target() {
    let mut spring = Spring::new(0.0, 100.0);
    spring.update(0.016);
    // Velocity should be positive (toward 100)
    assert!(spring.velocity() > 0.0);
}

#[test]
fn test_spring_velocity_from_target() {
    let mut spring = Spring::new(100.0, 0.0);
    spring.update(0.016);
    // Velocity should be negative (toward 0)
    assert!(spring.velocity() < 0.0);
}

#[test]
fn test_spring_is_settled_near_target() {
    let mut spring = Spring::new(0.0, 10.0);
    // Move close to target
    for _ in 0..1000 {
        spring.update(0.016);
        if spring.is_settled() {
            break;
        }
    }
    // Should eventually settle
    assert!(spring.is_settled());
    assert!((spring.value() - 10.0).abs() < 0.1);
}