Remove `rstest` dependency (#462)
* Remove rstest dependency
* Shorter function names to reduce wrapping
a92b9441fcb75f66114c9dd6eab73c969ec939be · ruwaq Nico Burns · (3 wata ñawpaq) · tayta 4a59cd45c · kay commitpi sach'ata qhaway
diff --git a/Cargo.toml b/Cargo.toml
index 1e648cfa3..d7c18423e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,6 @@ profile = []
taffy_tree = ["dep:slotmap"]
[dev-dependencies]
-rstest = "0.17.0"
serde_json = "1.0.93"
# Enable default features for tests and examples
diff --git a/src/util/math.rs b/src/util/math.rs
index 286219385..f9a43a678 100644
--- a/src/util/math.rs
+++ b/src/util/math.rs
@@ -251,124 +251,106 @@ impl<In, Out, T: MaybeMath<In, Out>> MaybeMath<Size<In>, Size<Out>> for Size<T>
#[cfg(test)]
mod tests {
mod lhs_option_f32_rhs_option_f32 {
-
use crate::util::MaybeMath;
- use rstest::rstest;
- #[rstest]
- #[case(Some(3.0), Some(5.0), Some(3.0))]
- #[case(Some(5.0), Some(3.0), Some(3.0))]
- #[case(Some(3.0), None, Some(3.0))]
- #[case(None, Some(3.0), None)]
- #[case(None, None, None)]
- fn test_maybe_min(#[case] lhs: Option<f32>, #[case] rhs: Option<f32>, #[case] expected: Option<f32>) {
- assert_eq!(lhs.maybe_min(rhs), expected);
+ #[test]
+ fn test_maybe_min() {
+ assert_eq!(Some(3.0).maybe_min(Some(5.0)), Some(3.0));
+ assert_eq!(Some(5.0).maybe_min(Some(3.0)), Some(3.0));
+ assert_eq!(Some(3.0).maybe_min(None), Some(3.0));
+ assert_eq!(None.maybe_min(Some(3.0)), None);
+ assert_eq!(None.maybe_min(None), None);
}
- #[rstest]
- #[case(Some(3.0), Some(5.0), Some(5.0))]
- #[case(Some(5.0), Some(3.0), Some(5.0))]
- #[case(Some(3.0), None, Some(3.0))]
- #[case(None, Some(3.0), None)]
- #[case(None, None, None)]
- fn test_maybe_max(#[case] lhs: Option<f32>, #[case] rhs: Option<f32>, #[case] expected: Option<f32>) {
- assert_eq!(lhs.maybe_max(rhs), expected);
+ #[test]
+ fn test_maybe_max() {
+ assert_eq!(Some(3.0).maybe_max(Some(5.0)), Some(5.0));
+ assert_eq!(Some(5.0).maybe_max(Some(3.0)), Some(5.0));
+ assert_eq!(Some(3.0).maybe_max(None), Some(3.0));
+ assert_eq!(None.maybe_max(Some(3.0)), None);
+ assert_eq!(None.maybe_max(None), None);
}
- #[rstest]
- #[case(Some(3.0), Some(5.0), Some(8.0))]
- #[case(Some(5.0), Some(3.0), Some(8.0))]
- #[case(Some(3.0), None, Some(3.0))]
- #[case(None, Some(3.0), None)]
- #[case(None, None, None)]
- fn test_maybe_add(#[case] lhs: Option<f32>, #[case] rhs: Option<f32>, #[case] expected: Option<f32>) {
- assert_eq!(lhs.maybe_add(rhs), expected);
+ #[test]
+ fn test_maybe_add() {
+ assert_eq!(Some(3.0).maybe_add(Some(5.0)), Some(8.0));
+ assert_eq!(Some(5.0).maybe_add(Some(3.0)), Some(8.0));
+ assert_eq!(Some(3.0).maybe_add(None), Some(3.0));
+ assert_eq!(None.maybe_add(Some(3.0)), None);
+ assert_eq!(None.maybe_add(None), None);
}
- #[rstest]
- #[case(Some(3.0), Some(5.0), Some(-2.0))]
- #[case(Some(5.0), Some(3.0), Some(2.0))]
- #[case(Some(3.0), None, Some(3.0))]
- #[case(None, Some(3.0), None)]
- #[case(None, None, None)]
- fn test_maybe_sub(#[case] lhs: Option<f32>, #[case] rhs: Option<f32>, #[case] expected: Option<f32>) {
- assert_eq!(lhs.maybe_sub(rhs), expected);
+ #[test]
+ fn test_maybe_sub() {
+ assert_eq!(Some(3.0).maybe_sub(Some(5.0)), Some(-2.0));
+ assert_eq!(Some(5.0).maybe_sub(Some(3.0)), Some(2.0));
+ assert_eq!(Some(3.0).maybe_sub(None), Some(3.0));
+ assert_eq!(None.maybe_sub(Some(3.0)), None);
+ assert_eq!(None.maybe_sub(None), None);
}
}
mod lhs_option_f32_rhs_f32 {
-
use crate::util::MaybeMath;
- use rstest::rstest;
- #[rstest]
- #[case(Some(3.0), 5.0, Some(3.0))]
- #[case(Some(5.0), 3.0, Some(3.0))]
- #[case(None, 3.0, None)]
- fn test_maybe_min(#[case] lhs: Option<f32>, #[case] rhs: f32, #[case] expected: Option<f32>) {
- assert_eq!(lhs.maybe_min(rhs), expected);
+ #[test]
+ fn test_maybe_min() {
+ assert_eq!(Some(3.0).maybe_min(5.0), Some(3.0));
+ assert_eq!(Some(5.0).maybe_min(3.0), Some(3.0));
+ assert_eq!(None.maybe_min(3.0), None);
}
- #[rstest]
- #[case(Some(3.0), 5.0, Some(5.0))]
- #[case(Some(5.0), 3.0, Some(5.0))]
- #[case(None, 3.0, None)]
- fn test_maybe_max(#[case] lhs: Option<f32>, #[case] rhs: f32, #[case] expected: Option<f32>) {
- assert_eq!(lhs.maybe_max(rhs), expected);
+ #[test]
+ fn test_maybe_max() {
+ assert_eq!(Some(3.0).maybe_max(5.0), Some(5.0));
+ assert_eq!(Some(5.0).maybe_max(3.0), Some(5.0));
+ assert_eq!(None.maybe_max(3.0), None);
}
- #[rstest]
- #[case(Some(3.0), 5.0, Some(8.0))]
- #[case(Some(5.0), 3.0, Some(8.0))]
- #[case(None, 3.0, None)]
- fn test_maybe_add(#[case] lhs: Option<f32>, #[case] rhs: f32, #[case] expected: Option<f32>) {
- assert_eq!(lhs.maybe_add(rhs), expected);
+ #[test]
+ fn test_maybe_add() {
+ assert_eq!(Some(3.0).maybe_add(5.0), Some(8.0));
+ assert_eq!(Some(5.0).maybe_add(3.0), Some(8.0));
+ assert_eq!(None.maybe_add(3.0), None);
}
- #[rstest]
- #[case(Some(3.0), 5.0, Some(-2.0))]
- #[case(Some(5.0), 3.0, Some(2.0))]
- #[case(None, 3.0, None)]
- fn test_maybe_sub(#[case] lhs: Option<f32>, #[case] rhs: f32, #[case] expected: Option<f32>) {
- assert_eq!(lhs.maybe_sub(rhs), expected);
+ #[test]
+ fn test_maybe_sub() {
+ assert_eq!(Some(3.0).maybe_sub(5.0), Some(-2.0));
+ assert_eq!(Some(5.0).maybe_sub(3.0), Some(2.0));
+ assert_eq!(None.maybe_sub(3.0), None);
}
}
mod lhs_f32_rhs_option_f32 {
-
use crate::util::MaybeMath;
- use rstest::rstest;
-
- #[rstest]
- #[case(3.0, Some(5.0), 3.0)]
- #[case(5.0, Some(3.0), 3.0)]
- #[case(3.0, None, 3.0)]
- fn test_maybe_min(#[case] lhs: f32, #[case] rhs: Option<f32>, #[case] expected: f32) {
- assert_eq!(lhs.maybe_min(rhs), expected);
- }
-
- #[rstest]
- #[case(3.0, Some(5.0), 5.0)]
- #[case(5.0, Some(3.0), 5.0)]
- #[case(3.0, None, 3.0)]
- fn test_maybe_max(#[case] lhs: f32, #[case] rhs: Option<f32>, #[case] expected: f32) {
- assert_eq!(lhs.maybe_max(rhs), expected);
- }
-
- #[rstest]
- #[case(3.0, Some(5.0), 8.0)]
- #[case(5.0, Some(3.0), 8.0)]
- #[case(3.0, None, 3.0)]
- fn test_maybe_add(#[case] lhs: f32, #[case] rhs: Option<f32>, #[case] expected: f32) {
- assert_eq!(lhs.maybe_add(rhs), expected);
- }
-
- #[rstest]
- #[case(3.0, Some(5.0), -2.0)]
- #[case(5.0, Some(3.0), 2.0)]
- #[case(3.0, None, 3.0)]
- fn test_maybe_sub(#[case] lhs: f32, #[case] rhs: Option<f32>, #[case] expected: f32) {
- assert_eq!(lhs.maybe_sub(rhs), expected);
+
+ #[test]
+ fn test_maybe_min() {
+ assert_eq!(3.0.maybe_min(Some(5.0)), 3.0);
+ assert_eq!(5.0.maybe_min(Some(3.0)), 3.0);
+ assert_eq!(3.0.maybe_min(None), 3.0);
+ }
+
+ #[test]
+ fn test_maybe_max() {
+ assert_eq!(3.0.maybe_max(Some(5.0)), 5.0);
+ assert_eq!(5.0.maybe_max(Some(3.0)), 5.0);
+ assert_eq!(3.0.maybe_max(None), 3.0);
+ }
+
+ #[test]
+ fn test_maybe_add() {
+ assert_eq!(3.0.maybe_add(Some(5.0)), 8.0);
+ assert_eq!(5.0.maybe_add(Some(3.0)), 8.0);
+ assert_eq!(3.0.maybe_add(None), 3.0);
+ }
+
+ #[test]
+ fn test_maybe_sub() {
+ assert_eq!(3.0.maybe_sub(Some(5.0)), -2.0);
+ assert_eq!(5.0.maybe_sub(Some(3.0)), 2.0);
+ assert_eq!(3.0.maybe_sub(None), 3.0);
}
}
}
diff --git a/src/util/resolve.rs b/src/util/resolve.rs
index f62b36a67..bc1dceaf8 100644
--- a/src/util/resolve.rs
+++ b/src/util/resolve.rs
@@ -135,35 +135,53 @@ impl<Out: TaffyZero, T: ResolveOrZero<Option<f32>, Out>> ResolveOrZero<Option<f3
#[cfg(test)]
mod tests {
- mod maybe_resolve_dimension {
+ use super::{MaybeResolve, ResolveOrZero};
+ use crate::style_helpers::TaffyZero;
+ use core::fmt::Debug;
+
+ // MaybeResolve test runner
+ fn mr_case<Lhs, Rhs, Out>(input: Lhs, context: Rhs, expected: Out)
+ where
+ Lhs: MaybeResolve<Rhs, Out>,
+ Out: PartialEq + Debug,
+ {
+ assert_eq!(input.maybe_resolve(context), expected);
+ }
+
+ // ResolveOrZero test runner
+ fn roz_case<Lhs, Rhs, Out>(input: Lhs, context: Rhs, expected: Out)
+ where
+ Lhs: ResolveOrZero<Rhs, Out>,
+ Out: PartialEq + Debug + TaffyZero,
+ {
+ assert_eq!(input.resolve_or_zero(context), expected);
+ }
+ mod maybe_resolve_dimension {
+ use super::mr_case;
use crate::style::Dimension;
- use crate::util::MaybeResolve;
- use rstest::rstest;
/// `Dimension::Auto` should always return `None`
///
/// The parent / context should not affect the outcome.
- #[rstest]
- #[case(Dimension::Auto, None, None)]
- #[case(Dimension::Auto, Some(5.0), None)]
- #[case(Dimension::Auto, Some(-5.0), None)]
- #[case(Dimension::Auto, Some(0.), None)]
- fn resolve_auto(#[case] input: Dimension, #[case] context: Option<f32>, #[case] expected: Option<f32>) {
- assert_eq!(input.maybe_resolve(context), expected);
+ #[test]
+ fn resolve_auto() {
+ mr_case(Dimension::Auto, None, None);
+ mr_case(Dimension::Auto, Some(5.0), None);
+ mr_case(Dimension::Auto, Some(-5.0), None);
+ mr_case(Dimension::Auto, Some(0.), None);
}
/// `Dimension::Length` should always return `Some(f32)`
/// where the f32 value is the inner absolute length.
///
/// The parent / context should not affect the outcome.
- #[rstest]
- #[case(Dimension::Length(1.0), None, Some(1.0))]
- #[case(Dimension::Length(1.0), Some(5.0), Some(1.0))]
- #[case(Dimension::Length(1.0), Some(-5.0), Some(1.0))]
- #[case(Dimension::Length(1.0), Some(0.), Some(1.0))]
- fn resolve_length(#[case] input: Dimension, #[case] context: Option<f32>, #[case] expected: Option<f32>) {
- assert_eq!(input.maybe_resolve(context), expected);
+ #[test]
+ fn resolve_length() {
+ mr_case(Dimension::Length(1.0), None, Some(1.0));
+ mr_case(Dimension::Length(1.0), Some(5.0), Some(1.0));
+ mr_case(Dimension::Length(1.0), Some(-5.0), Some(1.0));
+ mr_case(Dimension::Length(1.0), Some(0.), Some(1.0));
}
/// `Dimension::Percent` should return `None` if context is `None`.
@@ -171,53 +189,41 @@ mod tests {
/// where the f32 value is the inner value of the percent * context value.
///
/// The parent / context __should__ affect the outcome.
- #[rstest]
- #[case(Dimension::Percent(1.0), None, None)]
- #[case(Dimension::Percent(1.0), Some(5.0), Some(5.0))]
- #[case(Dimension::Percent(1.0), Some(-5.0), Some(-5.0))]
- #[case(Dimension::Percent(1.0), Some(50.0), Some(50.0))]
- fn resolve_percent(#[case] input: Dimension, #[case] context: Option<f32>, #[case] expected: Option<f32>) {
- assert_eq!(input.maybe_resolve(context), expected);
+ #[test]
+ fn resolve_percent() {
+ mr_case(Dimension::Percent(1.0), None, None);
+ mr_case(Dimension::Percent(1.0), Some(5.0), Some(5.0));
+ mr_case(Dimension::Percent(1.0), Some(-5.0), Some(-5.0));
+ mr_case(Dimension::Percent(1.0), Some(50.0), Some(50.0));
}
}
mod maybe_resolve_size_dimension {
- use super::super::MaybeResolve;
+ use super::mr_case;
use crate::geometry::Size;
use crate::style::Dimension;
- use rstest::rstest;
/// Size<Dimension::Auto> should always return Size<None>
///
/// The parent / context should not affect the outcome.
- #[rstest]
- #[case(Size::auto(), Size::NONE, Size::NONE)]
- #[case(Size::auto(), Size::new(5.0, 5.0), Size::NONE)]
- #[case(Size::auto(), Size::new(-5.0, -5.0), Size::NONE)]
- #[case(Size::auto(), Size::new(0.0, 0.0), Size::NONE)]
- fn maybe_resolve_auto(
- #[case] input: Size<Dimension>,
- #[case] context: Size<Option<f32>>,
- #[case] expected: Size<Option<f32>>,
- ) {
- assert_eq!(input.maybe_resolve(context), expected);
+ #[test]
+ fn maybe_resolve_auto() {
+ mr_case(Size::<Dimension>::auto(), Size::NONE, Size::NONE);
+ mr_case(Size::<Dimension>::auto(), Size::new(5.0, 5.0), Size::NONE);
+ mr_case(Size::<Dimension>::auto(), Size::new(-5.0, -5.0), Size::NONE);
+ mr_case(Size::<Dimension>::auto(), Size::new(0.0, 0.0), Size::NONE);
}
/// Size<Dimension::Length> should always return a Size<Some(f32)>
/// where the f32 values are the absolute length.
///
/// The parent / context should not affect the outcome.
- #[rstest]
- #[case(Size::from_lengths(5.0, 5.0), Size::NONE, Size::new(5.0, 5.0))]
- #[case(Size::from_lengths(5.0, 5.0), Size::new(5.0, 5.0), Size::new(5.0, 5.0))]
- #[case(Size::from_lengths(5.0, 5.0), Size::new(-5.0, -5.0), Size::new(5.0, 5.0))]
- #[case(Size::from_lengths(5.0, 5.0), Size::new(0.0, 0.0), Size::new(5.0, 5.0))]
- fn maybe_resolve_length(
- #[case] input: Size<Dimension>,
- #[case] context: Size<Option<f32>>,
- #[case] expected: Size<Option<f32>>,
- ) {
- assert_eq!(input.maybe_resolve(context), expected);
+ #[test]
+ fn maybe_resolve_length() {
+ mr_case(Size::from_lengths(5.0, 5.0), Size::NONE, Size::new(5.0, 5.0));
+ mr_case(Size::from_lengths(5.0, 5.0), Size::new(5.0, 5.0), Size::new(5.0, 5.0));
+ mr_case(Size::from_lengths(5.0, 5.0), Size::new(-5.0, -5.0), Size::new(5.0, 5.0));
+ mr_case(Size::from_lengths(5.0, 5.0), Size::new(0.0, 0.0), Size::new(5.0, 5.0));
}
/// `Size<Dimension::Percent>` should return `Size<None>` if context is `Size<None>`.
@@ -225,140 +231,103 @@ mod tests {
/// where the f32 value is the inner value of the percent * context value.
///
/// The context __should__ affect the outcome.
- #[rstest]
- #[case(Size::from_percent(5.0, 5.0), Size::NONE, Size::NONE)]
- #[case(Size::from_percent(5.0, 5.0), Size::new(5.0, 5.0), Size::new(25.0, 25.0))]
- #[case(Size::from_percent(5.0, 5.0), Size::new(-5.0, -5.0), Size::new(-25.0, -25.0))]
- #[case(Size::from_percent(5.0, 5.0), Size::new(0.0, 0.0), Size::new(0.0, 0.0))]
- fn maybe_resolve_percent(
- #[case] input: Size<Dimension>,
- #[case] context: Size<Option<f32>>,
- #[case] expected: Size<Option<f32>>,
- ) {
- assert_eq!(input.maybe_resolve(context), expected);
+ #[test]
+ fn maybe_resolve_percent() {
+ mr_case(Size::from_percent(5.0, 5.0), Size::NONE, Size::NONE);
+ mr_case(Size::from_percent(5.0, 5.0), Size::new(5.0, 5.0), Size::new(25.0, 25.0));
+ mr_case(Size::from_percent(5.0, 5.0), Size::new(-5.0, -5.0), Size::new(-25.0, -25.0));
+ mr_case(Size::from_percent(5.0, 5.0), Size::new(0.0, 0.0), Size::new(0.0, 0.0));
}
}
mod resolve_or_zero_dimension_to_option_f32 {
+ use super::roz_case;
use crate::style::Dimension;
- use crate::util::ResolveOrZero;
- use rstest::rstest;
-
- #[rstest]
- #[case(Dimension::Auto, None, 0.0)]
- #[case(Dimension::Auto, Some(5.0), 0.0)]
- #[case(Dimension::Auto, Some(-5.0), 0.0)]
- #[case(Dimension::Auto, Some(0.0), 0.0)]
- fn resolve_or_zero_auto(#[case] input: Dimension, #[case] context: Option<f32>, #[case] expected: f32) {
- assert_eq!(input.resolve_or_zero(context), expected);
+
+ #[test]
+ fn resolve_or_zero_auto() {
+ roz_case(Dimension::Auto, None, 0.0);
+ roz_case(Dimension::Auto, Some(5.0), 0.0);
+ roz_case(Dimension::Auto, Some(-5.0), 0.0);
+ roz_case(Dimension::Auto, Some(0.0), 0.0);
}
- #[rstest]
- #[case(Dimension::Length(5.0), None, 5.0)]
- #[case(Dimension::Length(5.0), Some(5.0), 5.0)]
- #[case(Dimension::Length(5.0), Some(-5.0), 5.0)]
- #[case(Dimension::Length(5.0), Some(0.0), 5.0)]
- fn resolve_or_zero_length(#[case] input: Dimension, #[case] context: Option<f32>, #[case] expected: f32) {
- assert_eq!(input.resolve_or_zero(context), expected);
+ #[test]
+ fn resolve_or_zero_length() {
+ roz_case(Dimension::Length(5.0), None, 5.0);
+ roz_case(Dimension::Length(5.0), Some(5.0), 5.0);
+ roz_case(Dimension::Length(5.0), Some(-5.0), 5.0);
+ roz_case(Dimension::Length(5.0), Some(0.0), 5.0);
}
- #[rstest]
- #[case(Dimension::Percent(5.0), None, 0.0)]
- #[case(Dimension::Percent(5.0), Some(5.0), 25.0)]
- #[case(Dimension::Percent(5.0), Some(-5.0), -25.0)]
- #[case(Dimension::Percent(5.0), Some(0.0), 0.0)]
- fn resolve_or_zero_percent(#[case] input: Dimension, #[case] context: Option<f32>, #[case] expected: f32) {
- assert_eq!(input.resolve_or_zero(context), expected);
+ #[test]
+ fn resolve_or_zero_percent() {
+ roz_case(Dimension::Percent(5.0), None, 0.0);
+ roz_case(Dimension::Percent(5.0), Some(5.0), 25.0);
+ roz_case(Dimension::Percent(5.0), Some(-5.0), -25.0);
+ roz_case(Dimension::Percent(5.0), Some(0.0), 0.0);
}
}
mod resolve_or_zero_rect_dimension_to_rect {
+ use super::roz_case;
use crate::geometry::{Rect, Size};
use crate::style::Dimension;
- use crate::util::ResolveOrZero;
- use rstest::rstest;
-
- #[rstest]
- #[case(Rect::auto(), Size::NONE, Rect::zero())]
- #[case(Rect::auto(), Size::new(5.0, 5.0), Rect::zero())]
- #[case(Rect::auto(), Size::new(-5.0, -5.0), Rect::zero())]
- #[case(Rect::auto(), Size::new(0.0, 0.0), Rect::zero())]
- fn resolve_or_zero_auto(
- #[case] input: Rect<Dimension>,
- #[case] context: Size<Option<f32>>,
- #[case] expected: Rect<f32>,
- ) {
- assert_eq!(input.resolve_or_zero(context), expected);
+
+ #[test]
+ fn resolve_or_zero_auto() {
+ roz_case(Rect::<Dimension>::auto(), Size::NONE, Rect::zero());
+ roz_case(Rect::<Dimension>::auto(), Size::new(5.0, 5.0), Rect::zero());
+ roz_case(Rect::<Dimension>::auto(), Size::new(-5.0, -5.0), Rect::zero());
+ roz_case(Rect::<Dimension>::auto(), Size::new(0.0, 0.0), Rect::zero());
}
- #[rstest]
- #[case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Size::NONE, Rect::new(5.0, 5.0, 5.0, 5.0))]
- #[case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Size::new(5.0, 5.0), Rect::new(5.0, 5.0, 5.0, 5.0))]
- #[case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Size::new(-5.0, -5.0), Rect::new(5.0, 5.0, 5.0, 5.0))]
- #[case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Size::new(0.0, 0.0), Rect::new(5.0, 5.0, 5.0, 5.0))]
- fn resolve_or_zero_length(
- #[case] input: Rect<Dimension>,
- #[case] context: Size<Option<f32>>,
- #[case] expected: Rect<f32>,
- ) {
- assert_eq!(input.resolve_or_zero(context), expected);
+ #[test]
+ fn resolve_or_zero_length() {
+ roz_case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Size::NONE, Rect::new(5.0, 5.0, 5.0, 5.0));
+ roz_case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Size::new(5.0, 5.0), Rect::new(5.0, 5.0, 5.0, 5.0));
+ roz_case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Size::new(-5.0, -5.0), Rect::new(5.0, 5.0, 5.0, 5.0));
+ roz_case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Size::new(0.0, 0.0), Rect::new(5.0, 5.0, 5.0, 5.0));
}
- #[rstest]
- #[case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Size::NONE, Rect::zero())]
- #[case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Size::new(5.0, 5.0), Rect::new(25.0, 25.0, 25.0, 25.0))]
- #[case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Size::new(-5.0, -5.0), Rect::new(-25.0, -25.0, -25.0, -25.0))]
- #[case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Size::new(0.0, 0.0), Rect::zero())]
- fn resolve_or_zero_percent(
- #[case] input: Rect<Dimension>,
- #[case] context: Size<Option<f32>>,
- #[case] expected: Rect<f32>,
- ) {
- assert_eq!(input.resolve_or_zero(context), expected);
+ #[test]
+ fn resolve_or_zero_percent() {
+ roz_case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Size::NONE, Rect::zero());
+ roz_case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Size::new(5.0, 5.0), Rect::new(25.0, 25.0, 25.0, 25.0));
+ roz_case(
+ Rect::from_percent(5.0, 5.0, 5.0, 5.0),
+ Size::new(-5.0, -5.0),
+ Rect::new(-25.0, -25.0, -25.0, -25.0),
+ );
+ roz_case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Size::new(0.0, 0.0), Rect::zero());
}
}
mod resolve_or_zero_rect_dimension_to_rect_f32_via_option {
+ use super::roz_case;
use crate::geometry::Rect;
use crate::style::Dimension;
- use crate::util::ResolveOrZero;
- use rstest::rstest;
-
- #[rstest]
- #[case(Rect::auto(), None, Rect::zero())]
- #[case(Rect::auto(), Some(5.0), Rect::zero())]
- #[case(Rect::auto(), Some(-5.0), Rect::zero())]
- #[case(Rect::auto(), Some(0.0), Rect::zero())]
- fn resolve_or_zero_auto(
- #[case] input: Rect<Dimension>,
- #[case] context: Option<f32>,
- #[case] expected: Rect<f32>,
- ) {
- assert_eq!(input.resolve_or_zero(context), expected);
+
+ #[test]
+ fn resolve_or_zero_auto() {
+ roz_case(Rect::<Dimension>::auto(), None, Rect::zero());
+ roz_case(Rect::<Dimension>::auto(), Some(5.0), Rect::zero());
+ roz_case(Rect::<Dimension>::auto(), Some(-5.0), Rect::zero());
+ roz_case(Rect::<Dimension>::auto(), Some(0.0), Rect::zero());
}
- #[rstest]
- #[case(Rect::from_length(5.0, 5.0, 5.0, 5.0), None, Rect::new(5.0, 5.0, 5.0, 5.0))]
- #[case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Some(5.0), Rect::new(5.0, 5.0, 5.0, 5.0))]
- #[case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Some(-5.0), Rect::new(5.0, 5.0, 5.0, 5.0))]
- #[case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Some(0.0), Rect::new(5.0, 5.0, 5.0, 5.0))]
- fn resolve_or_zero_length(
- #[case] input: Rect<Dimension>,
- #[case] context: Option<f32>,
- #[case] expected: Rect<f32>,
- ) {
- assert_eq!(input.resolve_or_zero(context), expected);
+ #[test]
+ fn resolve_or_zero_length() {
+ roz_case(Rect::from_length(5.0, 5.0, 5.0, 5.0), None, Rect::new(5.0, 5.0, 5.0, 5.0));
+ roz_case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Some(5.0), Rect::new(5.0, 5.0, 5.0, 5.0));
+ roz_case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Some(-5.0), Rect::new(5.0, 5.0, 5.0, 5.0));
+ roz_case(Rect::from_length(5.0, 5.0, 5.0, 5.0), Some(0.0), Rect::new(5.0, 5.0, 5.0, 5.0));
}
- #[rstest]
- #[case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), None, Rect::zero())]
- #[case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Some(5.0), Rect::new(25.0, 25.0, 25.0, 25.0))]
- #[case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Some(-5.0), Rect::new(-25.0, -25.0, -25.0, -25.0))]
- #[case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Some(0.0), Rect::zero())]
- fn resolve_or_zero_percent(
- #[case] input: Rect<Dimension>,
- #[case] context: Option<f32>,
- #[case] expected: Rect<f32>,
- ) {
- assert_eq!(input.resolve_or_zero(context), expected);
+ #[test]
+ fn resolve_or_zero_percent() {
+ roz_case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), None, Rect::zero());
+ roz_case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Some(5.0), Rect::new(25.0, 25.0, 25.0, 25.0));
+ roz_case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Some(-5.0), Rect::new(-25.0, -25.0, -25.0, -25.0));
+ roz_case(Rect::from_percent(5.0, 5.0, 5.0, 5.0), Some(0.0), Rect::zero());
}
}
}