Fix tests

Author: egorsmkv

.cargo/config.toml

@@ -1,2 +1,2 @@
 [build]
-target = "x86_64-unknown-linux-musl"
+#target = "x86_64-unknown-linux-musl"

src/main.rs

@@ -134,7 +134,7 @@ pub fn process_wav(input_path: &Path, output_path: &Path) -> Result<(), Box<dyn
 fn resample(input: &[f32], input_rate: f32, output_rate: f32) -> Result<Vec<f32>, Box<dyn Error>> {
     println!("Resampling from {} Hz to {} Hz", input_rate, output_rate);
 
-    let ratio = output_rate / input_rate;
+    let ratio = (output_rate / input_rate) as f64;
     let sinc_params = SincInterpolationParameters {
         sinc_len: 256,
         f_cutoff: 0.95,
@@ -145,7 +145,7 @@ fn resample(input: &[f32], input_rate: f32, output_rate: f32) -> Result<Vec<f32>
 
     let chunk_size = 1024; // Matches constructor argument for consistency.
     let mut resampler = SincFixedIn::<f64>::new(
-        ratio as f64,
+        ratio,
         1.0, // nb_channels as f64
         sinc_params,
         chunk_size,
@@ -180,6 +180,12 @@ fn resample(input: &[f32], input_rate: f32, output_rate: f32) -> Result<Vec<f32>
         output.extend_from_slice(&waves_out[0]);
     }
 
+    // Truncate to the expected length to account for padding
+    let expected_len = (input.len() as f64 * ratio).round() as usize;
+    if output.len() > expected_len {
+        output.truncate(expected_len);
+    }
+
     Ok(output.into_iter().map(|s| s as f32).collect())
 }
 
@@ -188,7 +194,6 @@ mod tests {
     use super::*;
 
     use hound::WavSpec as InputSpec;
-    use std::fs::File;
 
     /// Generates a simple sine wave WAV file for testing.
     fn create_test_wav(
@@ -197,25 +202,23 @@ mod tests {
         rate: u32,
         freq: f32,
         duration: f32,
-    ) -> WavWriter<File> {
+    ) {
         let spec = InputSpec {
             channels,
             sample_rate: rate,
             bits_per_sample: 16,
             sample_format: SampleFormat::Int,
         };
         let mut writer = WavWriter::create(path, spec).unwrap();
-        let num_samples = (rate as f32 * duration) as usize / channels as usize;
-        for i in 0..num_samples {
+        let num_frames = (rate as f32 * duration) as usize;
+        for i in 0..num_frames {
             let t = i as f32 / rate as f32;
             let sample = (2.0 * std::f32::consts::PI * freq * t).sin();
             for _ in 0..channels as usize {
                 writer.write_sample((sample * 32767.0) as i16).unwrap();
             }
         }
         writer.finalize().unwrap();
-
-        WavWriter::new(File::create(path).unwrap(), spec).unwrap() // Reopen for test consistency, but actually we use the file
     }
 
     #[test]
@@ -264,11 +267,16 @@ mod tests {
         let output_file = dir.path().join("output.wav");
         process_wav(&input_file, &output_file).unwrap();
 
-        let mut reader = WavReader::open(&output_file).unwrap();
-        let samples_out: Vec<i16> = reader.samples().collect::<Result<_, _>>().unwrap();
+        let mut reader_out = WavReader::open(&output_file).unwrap();
+        let samples_out: Vec<i16> = reader_out.samples().collect::<Result<_, _>>().unwrap();
 
         let mut reader_in = WavReader::open(&input_file).unwrap();
         let samples_in: Vec<i16> = reader_in.samples().collect::<Result<_, _>>().unwrap();
-        assert_eq!(samples_out, samples_in); // No change beyond potential normalization
+
+        assert_eq!(samples_out.len(), samples_in.len());
+        assert!(samples_out
+            .iter()
+            .zip(&samples_in)
+            .all(|(&a, &b)| (a as i32 - b as i32).abs() <= 1));
     }
 }