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

//! Integration tests for once utilities
//! Extracted from src/utils/once.rs

use revue::utils::once::*;

#[test]
fn test_once_new() {
    let once = Once::new();
    assert!(!once.is_called());
}

#[test]
fn test_once_single_call() {
    let mut once = Once::new();
    assert!(once.call());
    assert!(once.is_called());
}

#[test]
fn test_once_multiple_calls() {
    let mut once = Once::new();
    assert!(once.call()); // First
    assert!(!once.call()); // Second
    assert!(!once.call()); // Third
    assert!(!once.call()); // Fourth
    assert!(once.is_called());
}

#[test]
fn test_once_reset() {
    let mut once = Once::new();
    assert!(once.call());
    assert!(!once.call());

    once.reset();
    assert!(!once.is_called());
    assert!(once.call());
    assert!(!once.call());
}

#[test]
fn test_once_from_true() {
    let mut once = Once::from(true);
    assert!(once.is_called());
    assert!(!once.call());
}

#[test]
fn test_once_from_false() {
    let mut once = Once::from(false);
    assert!(!once.is_called());
    assert!(once.call());
}

#[test]
fn test_once_helper() {
    let mut one_shot = once();
    assert!(one_shot.call());
    assert!(!one_shot.call());
}

#[test]
fn test_once_default() {
    let once = Once::default();
    assert!(!once.is_called());
}

#[test]
fn test_once_clone() {
    let mut once1 = Once::new();
    once1.call();

    let mut once2 = once1.clone();
    assert!(once2.is_called());
    assert!(!once2.call());
}

#[test]
fn test_once_clone_uncalled() {
    let once1 = Once::new();
    let mut once2 = once1.clone();

    assert!(once2.call());
    // Cloned Once has its own independent state
    assert!(!once1.is_called());
}

#[test]
fn test_once_in_loop() {
    let mut once = Once::new();
    let mut count = 0;

    for _ in 0..100 {
        if once.call() {
            count += 1;
        }
    }

    assert_eq!(count, 1);
}

#[test]
fn test_once_with_callback() {
    let mut once = Once::new();
    let mut executed = false;

    for _ in 0..10 {
        if once.call() {
            executed = true;
        }
    }

    assert!(executed);
}