fix: check all offline context options in constructor

Author: b-ma

src/buffer.rs

@@ -2,19 +2,10 @@
 use std::sync::Arc;
 
 use crate::{
-    assert_valid_channel_number, assert_valid_number_of_channels, assert_valid_sample_rate,
+    assert_valid_buffer_length, assert_valid_channel_number, assert_valid_number_of_channels,
+    assert_valid_sample_rate,
 };
 
-#[track_caller]
-#[inline(always)]
-pub(crate) fn assert_valid_length(length: usize) {
-    assert!(
-        length > 0,
-        "NotSupportedError - Invalid length: {:?} is less than or equal to minimum bound (0)",
-        length,
-    );
-}
-
 /// Options for constructing an [`AudioBuffer`]
 // dictionary AudioBufferOptions {
 //   unsigned long numberOfChannels = 1;
@@ -91,7 +82,7 @@ impl AudioBuffer {
     /// 32 being defined by the MAX_CHANNELS constant.
     pub fn new(options: AudioBufferOptions) -> Self {
         assert_valid_sample_rate(options.sample_rate);
-        assert_valid_length(options.length);
+        assert_valid_buffer_length(options.length);
         assert_valid_number_of_channels(options.number_of_channels);
 
         let silence = ChannelData::new(options.length);

src/context/mod.rs

@@ -153,7 +153,7 @@ mod tests {
 
     #[test]
     fn test_audio_context_registration_traits() {
-        let context = OfflineAudioContext::new(1, 0, 44100.);
+        let context = OfflineAudioContext::new(1, 1, 44100.);
         let registration = context.mock_registration();
 
         // we want to be able to ship AudioNodes to another thread, so the Registration should be
@@ -163,7 +163,7 @@ mod tests {
 
     #[test]
     fn test_offline_audio_context_send_sync() {
-        let context = OfflineAudioContext::new(1, 0, 44100.);
+        let context = OfflineAudioContext::new(1, 1, 44100.);
         require_send_sync_static(context);
     }
 
@@ -176,7 +176,7 @@ mod tests {
 
     #[test]
     fn test_decode_audio_data() {
-        let context = OfflineAudioContext::new(1, 0, 44100.);
+        let context = OfflineAudioContext::new(1, 1, 44100.);
         let file = std::fs::File::open("samples/sample.wav").unwrap();
         let audio_buffer = context.decode_audio_data_sync(file).unwrap();
 
@@ -195,15 +195,15 @@ mod tests {
     // disabled: symphonia cannot handle empty WAV-files
     #[allow(dead_code)]
     fn test_decode_audio_data_empty() {
-        let context = OfflineAudioContext::new(1, 0, 44100.);
+        let context = OfflineAudioContext::new(1, 1, 44100.);
         let file = std::fs::File::open("samples/empty_2c.wav").unwrap();
         let audio_buffer = context.decode_audio_data_sync(file).unwrap();
         assert_eq!(audio_buffer.length(), 0);
     }
 
     #[test]
     fn test_decode_audio_data_decoding_error() {
-        let context = OfflineAudioContext::new(1, 0, 44100.);
+        let context = OfflineAudioContext::new(1, 1, 44100.);
         let file = std::fs::File::open("samples/corrupt.wav").unwrap();
         assert!(context.decode_audio_data_sync(file).is_err());
     }
@@ -214,7 +214,7 @@ mod tests {
         let length = 2000;
         let sample_rate = 96_000.;
 
-        let context = OfflineAudioContext::new(1, 0, 44100.);
+        let context = OfflineAudioContext::new(1, 1, 44100.);
         let buffer = context.create_buffer(number_of_channels, length, sample_rate);
 
         assert_eq!(buffer.number_of_channels(), 3);

src/context/offline.rs

@@ -9,7 +9,10 @@ use crate::events::{
     Event, EventDispatch, EventHandler, EventPayload, EventType, OfflineAudioCompletionEvent,
 };
 use crate::render::RenderThread;
-use crate::{assert_valid_sample_rate, RENDER_QUANTUM_SIZE};
+use crate::{
+    assert_valid_buffer_length, assert_valid_number_of_channels, assert_valid_sample_rate,
+    RENDER_QUANTUM_SIZE,
+};
 
 use crate::events::EventLoop;
 use futures_channel::{mpsc, oneshot};
@@ -72,6 +75,8 @@ impl OfflineAudioContext {
     #[must_use]
     #[allow(clippy::missing_panics_doc)]
     pub fn new(number_of_channels: usize, length: usize, sample_rate: f32) -> Self {
+        assert_valid_number_of_channels(number_of_channels);
+        assert_valid_buffer_length(length);
         assert_valid_sample_rate(sample_rate);
 
         // communication channel to the render thread,

src/lib.rs

@@ -190,6 +190,23 @@ pub(crate) fn assert_valid_channel_number(channel_number: usize, number_of_chann
     );
 }
 
+/// Assert that the given value number is a valid buffer length, i.e. greater than zero
+///
+/// # Panics
+///
+/// This function will panic if:
+/// - the given value is not lower than or equal to zero
+///
+#[track_caller]
+#[inline(always)]
+pub(crate) fn assert_valid_buffer_length(length: usize) {
+    assert!(
+        length > 0,
+        "NotSupportedError - Invalid length: {:?} is less than or equal to minimum bound (0)",
+        length,
+    );
+}
+
 /// Assert that the given value number is a valid time information, i.e. greater
 /// than or equal to zero and finite.
 ///

src/node/dynamics_compressor.rs

@@ -488,38 +488,37 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_constructor() {
-        {
-            let context = OfflineAudioContext::new(1, 0, 44_100.);
-            let compressor = DynamicsCompressorNode::new(&context, Default::default());
-
-            assert_float_eq!(compressor.attack().value(), 0.003, abs <= 0.);
-            assert_float_eq!(compressor.knee().value(), 30., abs <= 0.);
-            assert_float_eq!(compressor.ratio().value(), 12., abs <= 0.);
-            assert_float_eq!(compressor.release().value(), 0.25, abs <= 0.);
-            assert_float_eq!(compressor.threshold().value(), -24., abs <= 0.);
-        }
+    fn test_constructor_default() {
+        let context = OfflineAudioContext::new(1, 1, 44_100.);
+        let compressor = DynamicsCompressorNode::new(&context, Default::default());
 
-        {
-            let context = OfflineAudioContext::new(1, 0, 44_100.);
-            let compressor = DynamicsCompressorNode::new(
-                &context,
-                DynamicsCompressorOptions {
-                    attack: 0.5,
-                    knee: 12.,
-                    ratio: 1.,
-                    release: 0.75,
-                    threshold: -60.,
-                    ..DynamicsCompressorOptions::default()
-                },
-            );
-
-            assert_float_eq!(compressor.attack().value(), 0.5, abs <= 0.);
-            assert_float_eq!(compressor.knee().value(), 12., abs <= 0.);
-            assert_float_eq!(compressor.ratio().value(), 1., abs <= 0.);
-            assert_float_eq!(compressor.release().value(), 0.75, abs <= 0.);
-            assert_float_eq!(compressor.threshold().value(), -60., abs <= 0.);
-        }
+        assert_float_eq!(compressor.attack().value(), 0.003, abs <= 0.);
+        assert_float_eq!(compressor.knee().value(), 30., abs <= 0.);
+        assert_float_eq!(compressor.ratio().value(), 12., abs <= 0.);
+        assert_float_eq!(compressor.release().value(), 0.25, abs <= 0.);
+        assert_float_eq!(compressor.threshold().value(), -24., abs <= 0.);
+    }
+
+    #[test]
+    fn test_constructor_non_default() {
+        let context = OfflineAudioContext::new(1, 1, 44_100.);
+        let compressor = DynamicsCompressorNode::new(
+            &context,
+            DynamicsCompressorOptions {
+                attack: 0.5,
+                knee: 12.,
+                ratio: 1.,
+                release: 0.75,
+                threshold: -60.,
+                ..DynamicsCompressorOptions::default()
+            },
+        );
+
+        assert_float_eq!(compressor.attack().value(), 0.5, abs <= 0.);
+        assert_float_eq!(compressor.knee().value(), 12., abs <= 0.);
+        assert_float_eq!(compressor.ratio().value(), 1., abs <= 0.);
+        assert_float_eq!(compressor.release().value(), 0.75, abs <= 0.);
+        assert_float_eq!(compressor.threshold().value(), -60., abs <= 0.);
     }
 
     #[test]