motion-core 0.1.0

Backend-independent motion engine primitives
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

//! Property tests for time arithmetic and animation sampling.

use motion_core::{Animation, FrameRate, Time, Tween};
use proptest::prelude::*;

#[derive(Clone, Copy)]
struct Infinite;

impl Animation<f64> for Infinite {
    fn sample(&self, time: Time) -> f64 {
        time.as_seconds()
    }
}

proptest! {
    #![proptest_config({
        let mut config = ProptestConfig::default();
        if std::env::var_os("PROPTEST_CASES").is_none() {
            config.cases = 128;
        }
        config
    })]

    #[test]
    fn signed_frame_boundaries_round_trip(
        frame in -1_000_000_i64..=1_000_000,
        numerator in 1_u32..=240_000,
        denominator in 1_u32..=10_000,
    ) {
        let rate = FrameRate::new(numerator, denominator);
        let boundary = Time::from_frame(frame, rate);
        prop_assert_eq!(boundary.to_frame(rate), frame);
        prop_assert_eq!(Time::from_ticks(boundary.ticks() - 1).to_frame(rate), frame - 1);
        prop_assert!(Time::from_frame(frame + 1, rate) > boundary);
    }

    #[test]
    fn finite_then_and_zip_obey_duration_and_boundary_rules(
        first_ticks in 0_i64..=1_000_000,
        second_ticks in 0_i64..=1_000_000,
        sample_ticks in -1_000_000_i64..=3_000_000,
    ) {
        let first = Tween::new(0.0_f64, 1.0, Time::from_ticks(first_ticks));
        let second = Tween::new(2.0_f64, 3.0, Time::from_ticks(second_ticks));
        let sample = Time::from_ticks(sample_ticks);
        let zipped = first.clone().zip(second.clone());
        prop_assert_eq!(zipped.duration(), Some(Time::from_ticks(first_ticks.max(second_ticks))));
        prop_assert_eq!(zipped.sample(sample), (first.sample(sample), second.sample(sample)));
        prop_assert_eq!(first.clone().zip(Infinite).duration(), None);
        prop_assert_eq!(Infinite.zip(first.clone()).duration(), None);
        let chained = first.then(second.clone());
        prop_assert_eq!(chained.duration(), Some(Time::from_ticks(first_ticks + second_ticks)));
        prop_assert_eq!(chained.sample(Time::from_ticks(first_ticks)), second.sample(Time::ZERO));
        prop_assert_eq!(chained.sample(Time::from_ticks(first_ticks + second_ticks)), 3.0);
    }
}