css_ast 0.0.23

CSS Abstract Syntax Trees with visitable nodes and style value types.
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
154
155
156
157
158

#[cfg(test)]
mod tests {
	use super::super::*;
	use crate::CssAtomSet;
	use css_parse::{assert_parse, assert_parse_error};

	#[test]
	fn size_test() {
		assert_eq!(std::mem::size_of::<AnimationNameStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationDurationStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationTimingFunctionStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationIterationCountStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationDirectionStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationPlayStateStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationDelayStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationFillModeStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationCompositionStyleValue>(), 32);
		assert_eq!(std::mem::size_of::<AnimationTimelineStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerBehaviorStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerTimelineStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerRangeStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerRangeStartStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerRangeEndStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerExitRangeStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerExitRangeStartStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerExitRangeEndStyleValue>(), 32);
		// assert_eq!(std::mem::size_of::<AnimationTriggerStyleValue>(), 32);
	}

	#[test]
	fn test_animation_delay() {
		assert_parse!(CssAtomSet::ATOMS, AnimationDelayStyleValue, "-5ms");
		assert_parse!(CssAtomSet::ATOMS, AnimationDelayStyleValue, "0s");
		assert_parse!(CssAtomSet::ATOMS, AnimationDelayStyleValue, "10s");
		assert_parse!(CssAtomSet::ATOMS, AnimationDelayStyleValue, "20s, 10s");
	}

	#[test]
	fn test_animation_delay_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDelayStyleValue, "0");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDelayStyleValue, "0px");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDelayStyleValue, "infinite");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDelayStyleValue, "1s 2s 3s");
	}

	#[test]
	fn test_animation_direction() {
		assert_parse!(CssAtomSet::ATOMS, AnimationDirectionStyleValue, "normal");
		assert_parse!(CssAtomSet::ATOMS, AnimationDirectionStyleValue, "reverse");
		assert_parse!(CssAtomSet::ATOMS, AnimationDirectionStyleValue, "alternate");
		assert_parse!(CssAtomSet::ATOMS, AnimationDirectionStyleValue, "alternate-reverse");
		assert_parse!(CssAtomSet::ATOMS, AnimationDirectionStyleValue, "normal, reverse, alternate, alternate-reverse");
	}

	#[test]
	fn test_animation_direction_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDirectionStyleValue, "auto");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDirectionStyleValue, "normal reverse");
	}

	#[test]
	fn test_animation_duration() {
		assert_parse!(CssAtomSet::ATOMS, AnimationDurationStyleValue, "3s");
		assert_parse!(CssAtomSet::ATOMS, AnimationDurationStyleValue, "500ms");
		assert_parse!(CssAtomSet::ATOMS, AnimationDurationStyleValue, "1s, 2s, 3s");
	}

	#[test]
	fn test_animation_duration_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDurationStyleValue, "0");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDurationStyleValue, "0px");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDurationStyleValue, "-3s");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDurationStyleValue, "infinite");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationDurationStyleValue, "1s 2s");
	}

	#[test]
	fn test_animation_fill_mode() {
		assert_parse!(CssAtomSet::ATOMS, AnimationFillModeStyleValue, "none");
		assert_parse!(CssAtomSet::ATOMS, AnimationFillModeStyleValue, "forwards");
		assert_parse!(CssAtomSet::ATOMS, AnimationFillModeStyleValue, "backwards");
		assert_parse!(CssAtomSet::ATOMS, AnimationFillModeStyleValue, "both");
		assert_parse!(CssAtomSet::ATOMS, AnimationFillModeStyleValue, "none, forwards, backwards, both");
	}

	#[test]
	fn test_animation_fill_mode_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationFillModeStyleValue, "auto");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationFillModeStyleValue, "forwards backwards");
	}

	#[test]
	fn test_animation_iteration_count() {
		assert_parse!(CssAtomSet::ATOMS, AnimationIterationCountStyleValue, "0");
		assert_parse!(CssAtomSet::ATOMS, AnimationIterationCountStyleValue, "3");
		assert_parse!(CssAtomSet::ATOMS, AnimationIterationCountStyleValue, "4.5");
		assert_parse!(CssAtomSet::ATOMS, AnimationIterationCountStyleValue, "infinite");
		assert_parse!(CssAtomSet::ATOMS, AnimationIterationCountStyleValue, "0, infinite, 3");
	}

	#[test]
	fn test_animation_iteration_count_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationIterationCountStyleValue, "auto");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationIterationCountStyleValue, "-2");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationIterationCountStyleValue, "3 4");
	}

	#[test]
	fn test_animation_name() {
		assert_parse!(CssAtomSet::ATOMS, AnimationNameStyleValue, "none");
		assert_parse!(CssAtomSet::ATOMS, AnimationNameStyleValue, "foo");
		assert_parse!(CssAtomSet::ATOMS, AnimationNameStyleValue, "ease-in");
		assert_parse!(CssAtomSet::ATOMS, AnimationNameStyleValue, "infinite");
		assert_parse!(CssAtomSet::ATOMS, AnimationNameStyleValue, "paused");
		assert_parse!(CssAtomSet::ATOMS, AnimationNameStyleValue, "first, second, third");
	}

	#[test]
	fn test_animation_name_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationNameStyleValue, "12");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationNameStyleValue, "one two");
	}

	#[test]
	fn test_animation_play_state() {
		assert_parse!(CssAtomSet::ATOMS, AnimationPlayStateStyleValue, "running");
		assert_parse!(CssAtomSet::ATOMS, AnimationPlayStateStyleValue, "paused");
		assert_parse!(CssAtomSet::ATOMS, AnimationPlayStateStyleValue, "running, paused");
	}

	#[test]
	fn test_animation_play_state_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationPlayStateStyleValue, "auto");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationPlayStateStyleValue, "paused running");
	}

	#[test]
	fn test_animation_composition() {
		assert_parse!(CssAtomSet::ATOMS, AnimationCompositionStyleValue, "replace");
		assert_parse!(CssAtomSet::ATOMS, AnimationCompositionStyleValue, "add");
		assert_parse!(CssAtomSet::ATOMS, AnimationCompositionStyleValue, "accumulate");
		assert_parse!(CssAtomSet::ATOMS, AnimationCompositionStyleValue, "replace, add, accumulate");
	}

	#[test]
	fn test_animation_composition_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationCompositionStyleValue, "auto");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationCompositionStyleValue, "add replace");
	}

	#[test]
	fn test_animation_timing_function_errors() {
		assert_parse_error!(CssAtomSet::ATOMS, AnimationTimingFunctionStyleValue, "steps(2,()start)");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationTimingFunctionStyleValue, "steps(2())");
		assert_parse_error!(CssAtomSet::ATOMS, AnimationTimingFunctionStyleValue, "steps(2,())");
	}
}