fix: handle taiko passed objects properly & improve testing

tests/gradual_taiko.rs

@@ -4,8 +4,11 @@
 ))]
 
 use rosu_pp::{
-    taiko::{TaikoGradualDifficulty, TaikoGradualPerformance, TaikoScoreState},
-    Beatmap, TaikoPP, TaikoStars,
+    taiko::{
+        TaikoGradualDifficulty, TaikoGradualPerformance, TaikoOwnedGradualPerformance,
+        TaikoScoreState,
+    },
+    Beatmap, TaikoPP,
 };
 
 mod common;
@@ -18,62 +21,6 @@ fn empty_map() {
     assert!(attrs.next().is_none());
 }
 
-#[test]
-fn iter_end_eq_regular() {
-    let map = test_map!(Taiko);
-    let regular = TaikoStars::new(&map).calculate();
-
-    let iter_end = TaikoGradualDifficulty::new(&map, 0)
-        .last()
-        .expect("empty iter");
-
-    assert_eq!(regular, iter_end);
-}
-
-#[test]
-fn correct_empty() {
-    let map = test_map!(Taiko);
-    let mut gradual = TaikoGradualPerformance::new(&map, 0);
-    let state = TaikoScoreState::default();
-
-    let first_attrs = gradual.nth(state.clone(), usize::MAX);
-
-    assert!(first_attrs.is_some());
-    assert!(gradual.next(state).is_none());
-}
-
-#[test]
-fn next_and_next_n() {
-    let map = test_map!(Taiko);
-    let state = TaikoScoreState::default();
-
-    let mut gradual1 = TaikoGradualPerformance::new(&map, 0);
-    let mut gradual2 = TaikoGradualPerformance::new(&map, 0);
-
-    for _ in 0..50 {
-        let _ = gradual1.next(state.clone());
-        let _ = gradual2.next(state.clone());
-    }
-
-    let n = 200;
-
-    for _ in 1..n {
-        let _ = gradual1.next(state.clone());
-    }
-
-    let state = TaikoScoreState {
-        max_combo: 246,
-        n300: 200,
-        n100: 40,
-        n_misses: 6,
-    };
-
-    let next = gradual1.next(state.clone());
-    let next_n = gradual2.nth(state, n - 1);
-
-    assert_eq!(next_n, next);
-}
-
 #[test]
 fn gradual_end_eq_regular() {
     let map = test_map!(Taiko);
@@ -87,27 +34,57 @@ fn gradual_end_eq_regular() {
         n_misses: 0,
     };
 
-    let gradual_end = gradual.nth(state, usize::MAX).unwrap();
+    let gradual_end = gradual.last(state).unwrap();
 
     assert_eq!(regular, gradual_end);
 }
 
 #[test]
-fn gradual_eq_regular_passed() {
+fn gradual_complete_next() {
     let map = test_map!(Taiko);
-    let n = 250;
+    let mods = 88; // HDHRDT
 
-    let regular = TaikoPP::new(&map).passed_objects(n).calculate();
-    let mut gradual = TaikoGradualPerformance::new(&map, 0);
+    let mut gradual = TaikoGradualPerformance::new(map, mods);
+    let mut gradual_2nd = TaikoGradualPerformance::new(map, mods);
+    let mut gradual_3rd = TaikoGradualPerformance::new(map, mods);
+    let mut gradual_owned = TaikoOwnedGradualPerformance::new(map.to_owned(), mods);
 
-    let state = TaikoScoreState {
-        max_combo: 250,
-        n300: 250,
-        n100: 0,
-        n_misses: 0,
-    };
+    let mut state = TaikoScoreState::default();
 
-    let gradual = gradual.nth(state, n - 1).unwrap();
+    for i in 1.. {
+        state.n_misses += 1;
 
-    assert_eq!(regular, gradual);
+        let Some(next_gradual) = gradual.next(state.clone()) else {
+            assert_eq!(i, map.n_circles as usize + 1);
+            assert!(gradual_2nd.last(state.clone()).is_some() || map.hit_objects.len() % 2 == 0);
+            assert!(gradual_3rd.last(state.clone()).is_some() || map.hit_objects.len() % 3 == 0);
+            assert!(gradual_owned.next(state.clone()).is_none());
+            break;
+        };
+
+        if i % 2 == 0 {
+            let next_gradual_2nd = gradual_2nd.nth(state.clone(), 1).unwrap();
+            assert_eq!(next_gradual, next_gradual_2nd, "i={i}");
+        }
+
+        if i % 3 == 0 {
+            let next_gradual_3rd = gradual_3rd.nth(state.clone(), 2).unwrap();
+            assert_eq!(next_gradual, next_gradual_3rd, "i={i}");
+        }
+
+        let next_gradual_owned = gradual_owned.next(state.clone()).unwrap();
+
+        let mut regular_calc = TaikoPP::new(&map)
+            .mods(mods)
+            .passed_objects(i)
+            .state(state.clone());
+
+        let regular_state = regular_calc.generate_state();
+        assert_eq!(state, regular_state);
+
+        let regular = regular_calc.calculate();
+
+        assert_eq!(next_gradual, next_gradual_owned, "i={i}");
+        assert_eq!(next_gradual, regular, "i={i}");
+    }
 }