bevy_fuzz 0.0.2

Experimental high-performance fuzz-testing for bevy systems, emulating user UI interaction
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

use super::WrapElementState;
use bevy::{
    input::mouse::{MouseButtonInput, MouseScrollUnit, MouseWheel},
    prelude::MouseButton,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WrapMouseButtonInput {
    pub button: WrapMouseButton,
    pub state: WrapElementState,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum WrapMouseButton {
    Left,
    Right,
    Middle,
    Other(u16),
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
pub enum WrapMouseScrollUnit {
    Line,
    Pixel,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WrapMouseWheel {
    pub unit: WrapMouseScrollUnit,
    pub x: f32,
    pub y: f32,
}

impl From<&WrapMouseButtonInput> for MouseButtonInput {
    fn from(inp: &WrapMouseButtonInput) -> Self {
        MouseButtonInput {
            button: (&inp.button).into(),
            state: (&inp.state).into(),
        }
    }
}

impl From<&MouseButtonInput> for WrapMouseButtonInput {
    fn from(inp: &MouseButtonInput) -> Self {
        WrapMouseButtonInput {
            button: (&inp.button).into(),
            state: (&inp.state).into(),
        }
    }
}

impl From<&WrapMouseButton> for MouseButton {
    fn from(inp: &WrapMouseButton) -> Self {
        match inp {
            WrapMouseButton::Left => MouseButton::Left,
            WrapMouseButton::Right => MouseButton::Right,
            WrapMouseButton::Middle => MouseButton::Middle,
            WrapMouseButton::Other(v) => MouseButton::Other(*v),
        }
    }
}

impl From<&MouseButton> for WrapMouseButton {
    fn from(inp: &MouseButton) -> Self {
        match inp {
            MouseButton::Left => WrapMouseButton::Left,
            MouseButton::Right => WrapMouseButton::Right,
            MouseButton::Middle => WrapMouseButton::Middle,
            MouseButton::Other(v) => WrapMouseButton::Other(*v),
        }
    }
}

impl From<&WrapMouseScrollUnit> for MouseScrollUnit {
    fn from(inp: &WrapMouseScrollUnit) -> Self {
        match inp {
            WrapMouseScrollUnit::Line => MouseScrollUnit::Line,
            WrapMouseScrollUnit::Pixel => MouseScrollUnit::Pixel,
        }
    }
}

impl From<&MouseScrollUnit> for WrapMouseScrollUnit {
    fn from(inp: &MouseScrollUnit) -> Self {
        match inp {
            MouseScrollUnit::Line => WrapMouseScrollUnit::Line,
            MouseScrollUnit::Pixel => WrapMouseScrollUnit::Pixel,
        }
    }
}

impl From<&WrapMouseWheel> for MouseWheel {
    fn from(inp: &WrapMouseWheel) -> Self {
        MouseWheel {
            unit: (&inp.unit).into(),
            x: inp.x,
            y: inp.y,
        }
    }
}

impl From<&MouseWheel> for WrapMouseWheel {
    fn from(inp: &MouseWheel) -> Self {
        WrapMouseWheel {
            unit: (&inp.unit).into(),
            x: inp.x,
            y: inp.y,
        }
    }
}