Additional tests for FlexboxLayout and FlexDirection (#174)
* Additional tests for FlexboxLayout and FlexDirection
* Refactoring FlexboxLayout and FlexDirection tests
* Adding helper functions to Size and Rect
Co-authored-by: Marcello Vaz <marcello@pixodust.com>
Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
95934288c2c358836f303a7595ecd9fbe3efbd62 · ruwaq Marcello Vaz · 2022-06-19T15:55:10Z (4 wata ñawpaq) · tayta 61e084218kay commitpi sach'ata qhaway
diff --git a/src/geometry.rs b/src/geometry.rs
index 3c6abd1fe..110f20179 100644
--- a/src/geometry.rs
+++ b/src/geometry.rs
@@ -232,6 +232,16 @@ impl Size<f32> {
}
impl Size<Dimension> {
+ /// Generates a [`Size<Dimension>`] using [`Dimension::Points`] values
+ pub fn from_points(width: f32, height: f32) -> Self {
+ Size { width: Dimension::Points(width), height: Dimension::Points(height) }
+ }
+
+ /// Generates a [`Size<Dimension>`] using [`Dimension::Percent`] values
+ pub fn from_percent(width: f32, height: f32) -> Self {
+ Size { width: Dimension::Percent(width), height: Dimension::Percent(height) }
+ }
+
/// Converts any `parent`-relative values for size into an absolute size
pub(crate) fn resolve(&self, parent: Size<Option<f32>>) -> Size<Option<f32>> {
Size { width: self.width.resolve(parent.width), height: self.height.resolve(parent.height) }
diff --git a/src/style.rs b/src/style.rs
index 2db95c15b..8a946665c 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -292,6 +292,28 @@ impl Default for Rect<Dimension> {
}
}
+impl Rect<Dimension> {
+ /// Generates a [`Rect<Dimension>`] using [`Dimension::Points`] values for `start` and `top`
+ pub fn top_from_points(start: f32, top: f32) -> Rect<Dimension> {
+ Rect { start: Dimension::Points(start), top: Dimension::Points(top), ..Default::default() }
+ }
+
+ /// Generates a [`Rect<Dimension>`] using [`Dimension::Points`] values for `end` and `bottom`
+ pub fn bot_from_points(end: f32, bottom: f32) -> Rect<Dimension> {
+ Rect { end: Dimension::Points(end), bottom: Dimension::Points(bottom), ..Default::default() }
+ }
+
+ /// Generates a [`Rect<Dimension>`] using [`Dimension::Percent`] values for `start` and `top`
+ pub fn top_from_percent(start: f32, top: f32) -> Rect<Dimension> {
+ Rect { start: Dimension::Percent(start), top: Dimension::Percent(top), ..Default::default() }
+ }
+
+ /// Generates a [`Rect<Dimension>`] using [`Dimension::Percent`] values for `end` and `bottom`
+ pub fn bot_from_percent(end: f32, bottom: f32) -> Rect<Dimension> {
+ Rect { end: Dimension::Percent(end), bottom: Dimension::Percent(bottom), ..Default::default() }
+ }
+}
+
impl Default for Size<Dimension> {
fn default() -> Self {
Self { width: Dimension::Auto, height: Dimension::Auto }
@@ -529,4 +551,153 @@ mod tests {
assert_eq!(input.resolve(parent), expected);
}
}
+
+ mod test_flex_direction {
+ use crate::style::*;
+
+ #[test]
+ fn flex_direction_is_row() {
+ assert_eq!(FlexDirection::Row.is_row(), true);
+ assert_eq!(FlexDirection::RowReverse.is_row(), true);
+ assert_eq!(FlexDirection::Column.is_row(), false);
+ assert_eq!(FlexDirection::ColumnReverse.is_row(), false);
+ }
+
+ #[test]
+ fn flex_direction_is_column() {
+ assert_eq!(FlexDirection::Row.is_column(), false);
+ assert_eq!(FlexDirection::RowReverse.is_column(), false);
+ assert_eq!(FlexDirection::Column.is_column(), true);
+ assert_eq!(FlexDirection::ColumnReverse.is_column(), true);
+ }
+
+ #[test]
+ fn flex_direction_is_reverse() {
+ assert_eq!(FlexDirection::Row.is_reverse(), false);
+ assert_eq!(FlexDirection::RowReverse.is_reverse(), true);
+ assert_eq!(FlexDirection::Column.is_reverse(), false);
+ assert_eq!(FlexDirection::ColumnReverse.is_reverse(), true);
+ }
+ }
+
+ mod test_flexbox_layout {
+ use crate::style::*;
+
+ fn layout_from_align_items(align: AlignItems) -> FlexboxLayout {
+ FlexboxLayout { align_items: align, ..Default::default() }
+ }
+
+ fn layout_from_align_self(align: AlignSelf) -> FlexboxLayout {
+ FlexboxLayout { align_self: align, ..Default::default() }
+ }
+
+ #[test]
+ fn flexbox_layout_min_main_size() {
+ let layout = FlexboxLayout { min_size: Size::from_points(1.0, 2.0), ..Default::default() };
+ assert_eq!(layout.min_main_size(FlexDirection::Row), Dimension::Points(1.0));
+ assert_eq!(layout.min_main_size(FlexDirection::Column), Dimension::Points(2.0));
+ }
+
+ #[test]
+ fn flexbox_layout_max_main_size() {
+ let layout = FlexboxLayout { max_size: Size::from_points(1.0, 2.0), ..Default::default() };
+ assert_eq!(layout.max_main_size(FlexDirection::Row), Dimension::Points(1.0));
+ assert_eq!(layout.max_main_size(FlexDirection::Column), Dimension::Points(2.0));
+ }
+
+ #[test]
+ fn flexbox_layout_main_margin_start() {
+ let layout = FlexboxLayout { margin: Rect::top_from_points(2.0, 1.0), ..Default::default() };
+ assert_eq!(layout.main_margin_start(FlexDirection::Row), Dimension::Points(2.0));
+ assert_eq!(layout.main_margin_start(FlexDirection::Column), Dimension::Points(1.0));
+ }
+
+ #[test]
+ fn flexbox_layout_main_margin_end() {
+ let layout = FlexboxLayout { margin: Rect::bot_from_points(2.0, 1.0), ..Default::default() };
+ assert_eq!(layout.main_margin_end(FlexDirection::Row), Dimension::Points(2.0));
+ assert_eq!(layout.main_margin_end(FlexDirection::Column), Dimension::Points(1.0));
+ }
+
+ #[test]
+ fn flexbox_layout_cross_size() {
+ let layout = FlexboxLayout { size: Size::from_points(1.0, 2.0), ..Default::default() };
+ assert_eq!(layout.cross_size(FlexDirection::Row), Dimension::Points(2.0));
+ assert_eq!(layout.cross_size(FlexDirection::Column), Dimension::Points(1.0));
+ }
+
+ #[test]
+ fn flexbox_layout_min_cross_size() {
+ let layout = FlexboxLayout { min_size: Size::from_points(1.0, 2.0), ..Default::default() };
+ assert_eq!(layout.min_cross_size(FlexDirection::Row), Dimension::Points(2.0));
+ assert_eq!(layout.min_cross_size(FlexDirection::Column), Dimension::Points(1.0));
+ }
+
+ #[test]
+ fn flexbox_layout_max_cross_size() {
+ let layout = FlexboxLayout { max_size: Size::from_points(1.0, 2.0), ..Default::default() };
+ assert_eq!(layout.max_cross_size(FlexDirection::Row), Dimension::Points(2.0));
+ assert_eq!(layout.max_cross_size(FlexDirection::Column), Dimension::Points(1.0));
+ }
+
+ #[test]
+ fn flexbox_layout_cross_margin_start() {
+ let layout = FlexboxLayout { margin: Rect::top_from_points(2.0, 1.0), ..Default::default() };
+ assert_eq!(layout.cross_margin_start(FlexDirection::Row), Dimension::Points(1.0));
+ assert_eq!(layout.cross_margin_start(FlexDirection::Column), Dimension::Points(2.0));
+ }
+
+ #[test]
+ fn flexbox_layout_cross_margin_end() {
+ let layout = FlexboxLayout { margin: Rect::bot_from_points(2.0, 1.0), ..Default::default() };
+ assert_eq!(layout.cross_margin_end(FlexDirection::Row), Dimension::Points(1.0));
+ assert_eq!(layout.cross_margin_end(FlexDirection::Column), Dimension::Points(2.0));
+ }
+
+ #[test]
+ fn flexbox_layout_align_self_auto() {
+ let parent = layout_from_align_items(AlignItems::FlexStart);
+ let layout = layout_from_align_self(AlignSelf::Auto);
+ assert_eq!(layout.align_self(&parent), AlignSelf::FlexStart);
+
+ let parent = layout_from_align_items(AlignItems::FlexEnd);
+ let layout = layout_from_align_self(AlignSelf::Auto);
+ assert_eq!(layout.align_self(&parent), AlignSelf::FlexEnd);
+
+ let parent = layout_from_align_items(AlignItems::Center);
+ let layout = layout_from_align_self(AlignSelf::Auto);
+ assert_eq!(layout.align_self(&parent), AlignSelf::Center);
+
+ let parent = layout_from_align_items(AlignItems::Baseline);
+ let layout = layout_from_align_self(AlignSelf::Auto);
+ assert_eq!(layout.align_self(&parent), AlignSelf::Baseline);
+
+ let parent = layout_from_align_items(AlignItems::Stretch);
+ let layout = layout_from_align_self(AlignSelf::Auto);
+ assert_eq!(layout.align_self(&parent), AlignSelf::Stretch);
+ }
+
+ #[test]
+ fn align_self() {
+ let parent = layout_from_align_items(AlignItems::FlexEnd);
+ let layout = layout_from_align_self(AlignSelf::FlexStart);
+ assert_eq!(layout.align_self(&parent), AlignSelf::FlexStart);
+
+ let parent = layout_from_align_items(AlignItems::FlexStart);
+ let layout = layout_from_align_self(AlignSelf::FlexEnd);
+ assert_eq!(layout.align_self(&parent), AlignSelf::FlexEnd);
+
+ let parent = layout_from_align_items(AlignItems::FlexStart);
+ let layout = layout_from_align_self(AlignSelf::Center);
+ assert_eq!(layout.align_self(&parent), AlignSelf::Center);
+
+ let parent = layout_from_align_items(AlignItems::FlexStart);
+ let layout = layout_from_align_self(AlignSelf::Baseline);
+ assert_eq!(layout.align_self(&parent), AlignSelf::Baseline);
+
+ let parent = layout_from_align_items(AlignItems::FlexStart);
+ let layout = layout_from_align_self(AlignSelf::Stretch);
+ assert_eq!(layout.align_self(&parent), AlignSelf::Stretch);
+ }
+ }
}