apply clippy in tests

src/osu/performance/gradual.rs

@@ -152,27 +152,27 @@ mod tests {
         for i in 1.. {
             state.n_misses += 1;
 
-            let Some(next_gradual) = gradual.next(state.clone()) else {
+            let Some(next_gradual) = gradual.next(state) else {
                 assert_eq!(i, hit_objects_len + 1);
-                assert!(gradual_2nd.last(state.clone()).is_some() || hit_objects_len % 2 == 0);
-                assert!(gradual_3rd.last(state.clone()).is_some() || hit_objects_len % 3 == 0);
+                assert!(gradual_2nd.last(state).is_some() || hit_objects_len % 2 == 0);
+                assert!(gradual_3rd.last(state).is_some() || hit_objects_len % 3 == 0);
                 break;
             };
 
             if i % 2 == 0 {
-                let next_gradual_2nd = gradual_2nd.nth(state.clone(), 1).unwrap();
+                let next_gradual_2nd = gradual_2nd.nth(state, 1).unwrap();
                 assert_eq!(next_gradual, next_gradual_2nd);
             }
 
             if i % 3 == 0 {
-                let next_gradual_3rd = gradual_3rd.nth(state.clone(), 2).unwrap();
+                let next_gradual_3rd = gradual_3rd.nth(state, 2).unwrap();
                 assert_eq!(next_gradual, next_gradual_3rd);
             }
 
             let mut regular_calc = OsuPerformance::new(converted.as_owned())
                 .mods(mods)
                 .passed_objects(i as u32)
-                .state(state.clone());
+                .state(state);
 
             let regular_state = regular_calc.generate_state();
             assert_eq!(state, regular_state);

src/taiko/performance/gradual.rs

@@ -155,27 +155,27 @@ mod tests {
         for i in 1.. {
             state.n_misses += 1;
 
-            let Some(next_gradual) = gradual.next(state.clone()) else {
+            let Some(next_gradual) = gradual.next(state) else {
                 assert_eq!(i, n_hits + 1);
-                assert!(gradual_2nd.last(state.clone()).is_some() || hit_objects_len % 2 == 0);
-                assert!(gradual_3rd.last(state.clone()).is_some() || hit_objects_len % 3 == 0);
+                assert!(gradual_2nd.last(state).is_some() || hit_objects_len % 2 == 0);
+                assert!(gradual_3rd.last(state).is_some() || hit_objects_len % 3 == 0);
                 break;
             };
 
             if i % 2 == 0 {
-                let next_gradual_2nd = gradual_2nd.nth(state.clone(), 1).unwrap();
+                let next_gradual_2nd = gradual_2nd.nth(state, 1).unwrap();
                 assert_eq!(next_gradual, next_gradual_2nd);
             }
 
             if i % 3 == 0 {
-                let next_gradual_3rd = gradual_3rd.nth(state.clone(), 2).unwrap();
+                let next_gradual_3rd = gradual_3rd.nth(state, 2).unwrap();
                 assert_eq!(next_gradual, next_gradual_3rd);
             }
 
             let mut regular_calc = TaikoPerformance::new(converted.as_owned())
                 .mods(mods)
                 .passed_objects(i as u32)
-                .state(state.clone());
+                .state(state);
 
             let regular_state = regular_calc.generate_state();
             assert_eq!(state, regular_state);

src/util/float_ext.rs

@@ -46,16 +46,16 @@ mod tests {
             (3.0, 3.0),
             (3.5, 4.0),
             (4.5, 4.0),
-            (4.500001, 5.0),
-            (3.499999, 3.0),
-            (3.500001, 4.0),
+            (4.500_001, 5.0),
+            (3.499_999, 3.0),
+            (3.500_001, 4.0),
             (100_000_000_002.5, 100_000_000_002.0),
             (-3.0, -3.0),
             (-3.5, -4.0),
             (-4.5, -4.0),
-            (-4.500001, -5.0),
-            (-3.499999, -3.0),
-            (-3.500001, -4.0),
+            (-4.500_001, -5.0),
+            (-3.499_999, -3.0),
+            (-3.500_001, -4.0),
             (-100_000_000_002.5, -100_000_000_002.0),
         ];
 

src/util/limited_queue.rs

@@ -245,12 +245,12 @@ mod test {
 
             let (head, tail) = queue.as_slices();
 
-            for i in 0..head.len() {
-                assert_eq!(queue.iter().nth(i), Some(&head[i]));
+            for (i, item) in head.iter().enumerate() {
+                assert_eq!(queue.iter().nth(i), Some(item));
             }
 
-            for i in 0..tail.len() {
-                assert_eq!(queue.iter().nth(head.len() + i), Some(&tail[i]));
+            for (i, item) in tail.iter().enumerate() {
+                assert_eq!(queue.iter().nth(head.len() + i), Some(item));
             }
 
             assert_eq!(queue.iter().nth(head.len() + tail.len() + 1), None);