Add more tests (#65)

Add some tests to fill gaps for:
- `UiPositionLens`
- `Animator::set_tweenable()` and `AssetAnimator::set_tweenable()`
- `Sequence::from_single()`
- `Delay`'s `then()`, `times_completed()`, and `set_progress()`

src/lens.rs

@@ -607,6 +607,44 @@ mod tests {
         assert!(transform.scale.abs_diff_eq(Vec3::new(0.3, 0.6, -1.2), 1e-5));
     }
 
+    #[cfg(feature = "bevy_ui")]
+    #[test]
+    fn ui_position() {
+        let mut lens = UiPositionLens {
+            start: UiRect {
+                left: Val::Px(0.),
+                top: Val::Px(0.),
+                right: Val::Auto,
+                bottom: Val::Percent(25.),
+            },
+            end: UiRect {
+                left: Val::Px(1.),
+                top: Val::Px(5.),
+                right: Val::Auto,
+                bottom: Val::Percent(45.),
+            },
+        };
+        let mut style = Style::default();
+
+        lens.lerp(&mut style, 0.);
+        assert_eq!(style.position.left, Val::Px(0.));
+        assert_eq!(style.position.top, Val::Px(0.));
+        assert_eq!(style.position.right, Val::Auto);
+        assert_eq!(style.position.bottom, Val::Percent(25.));
+
+        lens.lerp(&mut style, 1.);
+        assert_eq!(style.position.left, Val::Px(1.));
+        assert_eq!(style.position.top, Val::Px(5.));
+        assert_eq!(style.position.right, Val::Auto);
+        assert_eq!(style.position.bottom, Val::Percent(45.));
+
+        lens.lerp(&mut style, 0.3);
+        assert_eq!(style.position.left, Val::Px(0.3));
+        assert_eq!(style.position.top, Val::Px(1.5));
+        assert_eq!(style.position.right, Val::Auto);
+        assert_eq!(style.position.bottom, Val::Percent(31.));
+    }
+
     #[cfg(feature = "bevy_sprite")]
     #[test]
     fn colormaterial_color() {

src/lib.rs

@@ -487,13 +487,13 @@ mod tests {
         end: f32,
     }
 
-    #[derive(Debug, Component)]
+    #[derive(Debug, Default, Component)]
     struct DummyComponent {
         value: f32,
     }
 
     #[cfg(feature = "bevy_asset")]
-    #[derive(Debug, Reflect, TypeUuid)]
+    #[derive(Debug, Default, Reflect, TypeUuid)]
     #[uuid = "a33abc11-264e-4bbb-82e8-b87226bb4383"]
     struct DummyAsset {
         value: f32,
@@ -505,6 +505,16 @@ mod tests {
         }
     }
 
+    #[test]
+    fn dummy_lens_component() {
+        let mut c = DummyComponent::default();
+        let mut l = DummyLens { start: 0., end: 1. };
+        for r in [0_f32, 0.01, 0.3, 0.5, 0.9, 0.999, 1.] {
+            l.lerp(&mut c, r);
+            assert!(abs_diff_eq(c.value, r, 1e-5));
+        }
+    }
+
     #[cfg(feature = "bevy_asset")]
     impl Lens<DummyAsset> for DummyLens {
         fn lerp(&mut self, target: &mut DummyAsset, ratio: f32) {
@@ -512,6 +522,17 @@ mod tests {
         }
     }
 
+    #[cfg(feature = "bevy_asset")]
+    #[test]
+    fn dummy_lens_asset() {
+        let mut a = DummyAsset::default();
+        let mut l = DummyLens { start: 0., end: 1. };
+        for r in [0_f32, 0.01, 0.3, 0.5, 0.9, 0.999, 1.] {
+            l.lerp(&mut a, r);
+            assert!(abs_diff_eq(a.value, r, 1e-5));
+        }
+    }
+
     #[test]
     fn repeat_count() {
         let count = RepeatCount::default();
@@ -659,6 +680,25 @@ mod tests {
         assert!(abs_diff_eq(animator.speed(), 3.5, 1e-5));
     }
 
+    #[test]
+    fn animator_set_tweenable() {
+        let tween = Tween::<DummyComponent>::new(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut animator = Animator::new(tween);
+
+        let tween2 = Tween::<DummyComponent>::new(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(2),
+            DummyLens { start: 0., end: 1. },
+        );
+        animator.set_tweenable(tween2);
+
+        assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
+    }
+
     #[cfg(feature = "bevy_asset")]
     #[test]
     fn asset_animator_new() {
@@ -758,4 +798,24 @@ mod tests {
         let animator = AssetAnimator::new(Handle::<DummyAsset>::default(), tween).with_speed(3.5);
         assert!(abs_diff_eq(animator.speed(), 3.5, 1e-5));
     }
+
+    #[cfg(feature = "bevy_asset")]
+    #[test]
+    fn asset_animator_set_tweenable() {
+        let tween = Tween::new(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(1),
+            DummyLens { start: 0., end: 1. },
+        );
+        let mut animator = AssetAnimator::new(Handle::<DummyAsset>::default(), tween);
+
+        let tween2 = Tween::new(
+            EaseFunction::QuadraticInOut,
+            Duration::from_secs(2),
+            DummyLens { start: 0., end: 1. },
+        );
+        animator.set_tweenable(tween2);
+
+        assert_eq!(animator.tweenable().duration(), Duration::from_secs(2));
+    }
 }

src/tweenable.rs

@@ -1359,6 +1359,22 @@ mod tests {
         assert_eq!(seq.times_completed(), 0);
     }
 
+    /// Sequence::from_single()
+    #[test]
+    fn seq_from_single() {
+        let tween = Tween::new(
+            EaseMethod::Linear,
+            Duration::from_secs(1),
+            TransformPositionLens {
+                start: Vec3::ZERO,
+                end: Vec3::ONE,
+            },
+        );
+        let seq = Sequence::from_single(tween);
+
+        assert_eq!(seq.duration(), Duration::from_secs(1));
+    }
+
     /// Test ticking parallel tracks of tweens.
     #[test]
     fn tracks_tick() {
@@ -1455,10 +1471,22 @@ mod tests {
         assert_eq!(tracks.times_completed(), 0); // no looping
     }
 
+    /// Delay::then()
+    #[test]
+    fn delay_then() {
+        let seq: Sequence<Transform> =
+            Delay::new(Duration::from_secs(1)).then(Delay::new(Duration::from_secs(2)));
+        assert_eq!(seq.duration(), Duration::from_secs(3));
+        assert_eq!(seq.tweens.len(), 2);
+        for (i, t) in seq.tweens.iter().enumerate() {
+            assert_eq!(t.duration(), Duration::from_secs(i as u64 + 1));
+        }
+    }
+
     /// Test ticking a delay.
     #[test]
     fn delay_tick() {
-        let duration = Duration::from_secs_f32(1.0);
+        let duration = Duration::from_secs(1);
         let mut delay = Delay::new(duration);
         {
             let tweenable: &dyn Tweenable<Transform> = &delay;
@@ -1474,7 +1502,7 @@ mod tests {
 
         for i in 1..=6 {
             let state = delay.tick(
-                Duration::from_secs_f32(0.2),
+                Duration::from_millis(200),
                 &mut transform,
                 entity,
                 &mut event_writer,
@@ -1483,14 +1511,31 @@ mod tests {
                 let tweenable: &dyn Tweenable<Transform> = &delay;
                 if i < 5 {
                     assert_eq!(state, TweenState::Active);
+                    assert_eq!(tweenable.times_completed(), 0);
                     let r = i as f32 * 0.2;
                     assert!((tweenable.progress() - r).abs() < 1e-5);
                 } else {
                     assert_eq!(state, TweenState::Completed);
+                    assert_eq!(tweenable.times_completed(), 1);
                     assert!((tweenable.progress() - 1.).abs() < 1e-5);
                 }
             }
         }
+
+        let tweenable: &mut dyn Tweenable<Transform> = &mut delay;
+
+        tweenable.rewind();
+        assert_eq!(tweenable.times_completed(), 0);
+        assert!(abs_diff_eq(tweenable.progress(), 0., 1e-5));
+        let state = tweenable.tick(Duration::ZERO, &mut transform, entity, &mut event_writer);
+        assert_eq!(state, TweenState::Active);
+
+        tweenable.set_progress(0.3);
+        assert_eq!(tweenable.times_completed(), 0);
+        assert!(abs_diff_eq(tweenable.progress(), 0.3, 1e-5));
+        tweenable.set_progress(1.);
+        assert_eq!(tweenable.times_completed(), 1);
+        assert!(abs_diff_eq(tweenable.progress(), 1., 1e-5));
     }
 
     #[test]