Merge pull request #430 from orottier/feature/unify-panic-messages

Unify panic messages

Author: orottier

src/analysis.rs

@@ -33,42 +33,42 @@ const MAX_FFT_SIZE: usize = 32768;
 
 // [spec] This MUST be a power of two in the range 32 to 32768, otherwise an
 // IndexSizeError exception MUST be thrown.
+#[allow(clippy::manual_range_contains)]
 fn assert_valid_fft_size(fft_size: usize) {
-    if !fft_size.is_power_of_two() {
-        panic!(
-            "IndexSizeError - Invalid fft size: {:?} is not a power of two",
-            fft_size
-        );
-    }
-
-    if !(MIN_FFT_SIZE..=MAX_FFT_SIZE).contains(&fft_size) {
-        panic!(
-            "IndexSizeError - Invalid fft size: {:?} is outside range [{:?}, {:?}]",
-            fft_size, MIN_FFT_SIZE, MAX_FFT_SIZE
-        );
-    }
+    assert!(
+        fft_size.is_power_of_two(),
+        "IndexSizeError - Invalid fft size: {:?} is not a power of two",
+        fft_size
+    );
+
+    assert!(
+        fft_size >= MIN_FFT_SIZE && fft_size <= MAX_FFT_SIZE,
+        "IndexSizeError - Invalid fft size: {:?} is outside range [{:?}, {:?}]",
+        fft_size,
+        MIN_FFT_SIZE,
+        MAX_FFT_SIZE
+    );
 }
 
 // [spec] If the value of this attribute is set to a value less than 0 or more
 // than 1, an IndexSizeError exception MUST be thrown.
+#[allow(clippy::manual_range_contains)]
 fn assert_valid_smoothing_time_constant(smoothing_time_constant: f64) {
-    if !(0. ..=1.).contains(&smoothing_time_constant) {
-        panic!(
-            "IndexSizeError - Invalid smoothing time constant: {:?} is outside range [0, 1]",
-            smoothing_time_constant
-        );
-    }
+    assert!(
+        smoothing_time_constant >= 0. && smoothing_time_constant <= 1.,
+        "IndexSizeError - Invalid smoothing time constant: {:?} is outside range [0, 1]",
+        smoothing_time_constant
+    );
 }
 
 // [spec] If the value of minDecibels is set to a value more than or equal to maxDecibels, an
 // IndexSizeError exception MUST be thrown.
 fn assert_valid_decibels(min_decibels: f64, max_decibels: f64) {
-    if min_decibels >= max_decibels {
-        panic!(
-            "IndexSizeError - Invalid min decibels: {:?} is greater than or equals to max decibels {:?}",
-            min_decibels, max_decibels
-        );
-    }
+    assert!(
+        min_decibels < max_decibels,
+        "IndexSizeError - Invalid min decibels: {:?} is greater than or equals to max decibels {:?}",
+        min_decibels, max_decibels
+    );
 }
 
 // as the queue is composed of AtomicF32 having only 1 render quantum of extra

src/context/offline.rs

@@ -125,10 +125,12 @@ impl OfflineAudioContext {
     /// Panics if this method is called multiple times
     #[must_use]
     pub fn start_rendering_sync(&mut self) -> AudioBuffer {
-        let renderer = match self.renderer.lock().unwrap().take() {
-            None => panic!("InvalidStateError: Cannot call `startRendering` twice"),
-            Some(v) => v,
-        };
+        let renderer = self
+            .renderer
+            .lock()
+            .unwrap()
+            .take()
+            .expect("InvalidStateError - Cannot call `startRendering` twice");
         let OfflineAudioContextRenderer {
             renderer,
             suspend_callbacks,
@@ -155,10 +157,12 @@ impl OfflineAudioContext {
     /// Panics if this method is called multiple times.
     pub async fn start_rendering(&self) -> AudioBuffer {
         // We are mixing async with a std Mutex, so be sure not to `await` while the lock is held
-        let renderer = match self.renderer.lock().unwrap().take() {
-            None => panic!("InvalidStateError: Cannot call `startRendering` twice"),
-            Some(v) => v,
-        };
+        let renderer = self
+            .renderer
+            .lock()
+            .unwrap()
+            .take()
+            .expect("InvalidStateError - Cannot call `startRendering` twice");
 
         let OfflineAudioContextRenderer {
             renderer,
@@ -248,18 +252,15 @@ impl OfflineAudioContext {
         // We are mixing async with a std Mutex, so be sure not to `await` while the lock is held
         {
             let mut lock = self.renderer.lock().unwrap();
-            let renderer = match lock.as_mut() {
-                Some(r) => r,
-                None => {
-                    panic!("InvalidStateError: cannot suspend when rendering has already started")
-                }
-            };
+            let renderer = lock
+                .as_mut()
+                .expect("InvalidStateError - cannot suspend when rendering has already started");
 
             let insert_pos = renderer
                 .suspend_promises
                 .binary_search_by_key(&quantum, |&(q, _)| q)
                 .expect_err(
-                    "InvalidStateError: cannot suspend multiple times at the same render quantum",
+                    "InvalidStateError - cannot suspend multiple times at the same render quantum",
                 );
 
             renderer
@@ -316,16 +317,15 @@ impl OfflineAudioContext {
         let quantum = self.calculate_suspend_frame(suspend_time);
 
         let mut lock = self.renderer.lock().unwrap();
-        let renderer = match lock.as_mut() {
-            Some(r) => r,
-            None => panic!("InvalidStateError: cannot suspend when rendering has already started"),
-        };
+        let renderer = lock
+            .as_mut()
+            .expect("InvalidStateError - cannot suspend when rendering has already started");
 
         let insert_pos = renderer
             .suspend_callbacks
             .binary_search_by_key(&quantum, |(q, _c)| *q)
             .expect_err(
-                "InvalidStateError: cannot suspend multiple times at the same render quantum",
+                "InvalidStateError - cannot suspend multiple times at the same render quantum",
             );
 
         let boxed_callback = Box::new(|ctx: &mut OfflineAudioContext| {

src/decoding.rs

@@ -34,7 +34,7 @@ impl<R: Read> Read for MediaInput<R> {
 
 impl<R> Seek for MediaInput<R> {
     fn seek(&mut self, _pos: SeekFrom) -> std::io::Result<u64> {
-        panic!("MediaInput does not support seeking")
+        panic!("NotSupportedError - MediaInput does not support seeking")
     }
 }
 

src/io/cpal.rs

@@ -132,23 +132,23 @@ impl AudioBackendManager for CpalBackend {
 
         let device = if options.sink_id.is_empty() {
             host.default_output_device()
-                .expect("no output device available")
+                .expect("InvalidStateError - no output device available")
         } else {
             Self::enumerate_devices_sync()
                 .into_iter()
                 .find(|e| e.device_id() == options.sink_id)
                 .map(|e| *e.device().downcast::<cpal::Device>().unwrap())
                 .unwrap_or_else(|| {
                     host.default_output_device()
-                        .expect("no output device available")
+                        .expect("InvalidStateError - no output device available")
                 })
         };
 
         log::info!("Output device: {:?}", device.name());
 
         let default_device_config = device
             .default_output_config()
-            .expect("error while querying config");
+            .expect("InvalidStateError - error while querying device output config");
 
         // we grab the largest number of channels provided by the soundcard
         // clamped to MAX_CHANNELS, this value cannot be changed by the user
@@ -247,11 +247,15 @@ impl AudioBackendManager for CpalBackend {
                     Arc::clone(&output_latency),
                 );
 
-                spawned.expect("OutputStream build failed with default config")
+                spawned
+                    .expect("InvalidStateError - Unable to spawn output stream with default config")
             }
         };
 
-        stream.play().expect("Stream refused to play");
+        // Required because some hosts don't play the stream automatically
+        stream
+            .play()
+            .expect("InvalidStateError - Output stream refused to play");
 
         CpalBackend {
             stream: ThreadSafeClosableStream::new(stream),
@@ -272,23 +276,23 @@ impl AudioBackendManager for CpalBackend {
 
         let device = if options.sink_id.is_empty() {
             host.default_input_device()
-                .expect("no input device available")
+                .expect("InvalidStateError - no input device available")
         } else {
             Self::enumerate_devices_sync()
                 .into_iter()
                 .find(|e| e.device_id() == options.sink_id)
                 .map(|e| *e.device().downcast::<cpal::Device>().unwrap())
                 .unwrap_or_else(|| {
                     host.default_input_device()
-                        .expect("no input device available")
+                        .expect("InvalidStateError - no input device available")
                 })
         };
 
         log::info!("Input device: {:?}", device.name());
 
         let supported = device
             .default_input_config()
-            .expect("error while querying configs");
+            .expect("InvalidStateError - error while querying device input config");
 
         // clone the config, we may need to fall back on it later
         let mut preferred: StreamConfig = supported.clone().into();
@@ -349,12 +353,15 @@ impl AudioBackendManager for CpalBackend {
                     &supported_config,
                     renderer,
                 );
-                spawned.expect("Unable to spawn input stream with default config")
+                spawned
+                    .expect("InvalidStateError - Unable to spawn input stream with default config")
             }
         };
 
         // Required because some hosts don't play the stream automatically
-        stream.play().expect("Input stream refused to play");
+        stream
+            .play()
+            .expect("InvalidStateError - Input stream refused to play");
 
         let backend = CpalBackend {
             stream: ThreadSafeClosableStream::new(stream),

src/io/cubeb.rs

@@ -132,7 +132,9 @@ fn init_output_backend<const N: usize>(
             println!("stream state changed: {state:?}");
         });
 
-    let stream = builder.init(ctx).expect("Failed to create cubeb stream");
+    let stream = builder
+        .init(ctx)
+        .expect("InvalidStateError - Failed to create cubeb stream");
     ThreadSafeClosableStream::new(stream)
 }
 
@@ -346,7 +348,9 @@ impl AudioBackendManager for CubebBackend {
                 println!("stream state changed: {state:?}");
             });
 
-        let stream = builder.init(&ctx).expect("Failed to create cubeb stream");
+        let stream = builder
+            .init(&ctx)
+            .expect("InvalidStateError - Failed to create cubeb stream");
 
         stream.start().unwrap();
 

src/io/mod.rs

@@ -204,12 +204,11 @@ fn buffer_size_for_latency_category(
         #[allow(clippy::cast_sign_loss)]
         #[allow(clippy::cast_possible_truncation)]
         AudioContextLatencyCategory::Custom(latency) => {
-            if latency <= 0. {
-                panic!(
-                    "RangeError - Invalid custom latency: {:?}, should be strictly positive",
-                    latency
-                );
-            }
+            assert!(
+                latency > 0.,
+                "RangeError - Invalid custom latency: {:?}, should be strictly positive",
+                latency
+            );
 
             let buffer_size = (latency * sample_rate as f64) as usize;
             buffer_size.next_power_of_two()

src/lib.rs

@@ -158,12 +158,11 @@ impl AtomicF64 {
 pub(crate) fn assert_valid_sample_rate(sample_rate: f32) {
     // 1000 Hertz is a just a random cutoff, but it helps a if someone accidentally puts a
     // timestamp in the sample_rate variable
-    if sample_rate <= 1000. {
-        panic!(
-            "NotSupportedError - Invalid sample rate: {:?}, should be greater than 1000",
-            sample_rate
-        );
-    }
+    assert!(
+        sample_rate > 1000.,
+        "NotSupportedError - Invalid sample rate: {:?}, should be greater than 1000",
+        sample_rate
+    );
 }
 
 /// Assert that the given number of channels is valid.
@@ -177,12 +176,12 @@ pub(crate) fn assert_valid_sample_rate(sample_rate: f32) {
 #[track_caller]
 #[inline(always)]
 pub(crate) fn assert_valid_number_of_channels(number_of_channels: usize) {
-    if number_of_channels == 0 || number_of_channels > MAX_CHANNELS {
-        panic!(
-            "NotSupportedError - Invalid number of channels: {:?} is outside range [1, {:?}]",
-            number_of_channels, MAX_CHANNELS
-        );
-    }
+    assert!(
+        number_of_channels > 0 && number_of_channels <= MAX_CHANNELS,
+        "NotSupportedError - Invalid number of channels: {:?} is outside range [1, {:?}]",
+        number_of_channels,
+        MAX_CHANNELS
+    );
 }
 
 /// Assert that the given channel number is valid according to the number of channels
@@ -196,12 +195,12 @@ pub(crate) fn assert_valid_number_of_channels(number_of_channels: usize) {
 #[track_caller]
 #[inline(always)]
 pub(crate) fn assert_valid_channel_number(channel_number: usize, number_of_channels: usize) {
-    if channel_number >= number_of_channels {
-        panic!(
-            "IndexSizeError - Invalid channel number {:?} (number of channels: {:?})",
-            channel_number, number_of_channels
-        );
-    }
+    assert!(
+        channel_number < number_of_channels,
+        "IndexSizeError - Invalid channel number {:?} (number of channels: {:?})",
+        channel_number,
+        number_of_channels
+    );
 }
 
 /// Assert that the given value number is a valid time information, i.e. greater
@@ -215,16 +214,16 @@ pub(crate) fn assert_valid_channel_number(channel_number: usize, number_of_chann
 #[track_caller]
 #[inline(always)]
 pub(crate) fn assert_valid_time_value(value: f64) {
-    if !value.is_finite() {
-        panic!("TypeError - The provided time value is non-finite.");
-    }
-
-    if value < 0. {
-        panic!(
-            "RangeError - The provided time value ({:?}) cannot be negative",
-            value
-        );
-    }
+    assert!(
+        value.is_finite(),
+        "TypeError - The provided time value is non-finite.",
+    );
+
+    assert!(
+        value >= 0.,
+        "RangeError - The provided time value ({:?}) cannot be negative",
+        value
+    );
 }
 
 pub(crate) trait AudioBufferIter: Iterator<Item = FallibleBuffer> + Send + 'static {}

src/media_recorder/mod.rs

@@ -204,9 +204,11 @@ impl MediaRecorder {
     ///
     /// Will panic when the recorder has already started
     pub fn start(&self) {
-        if self.inner.active.swap(true, Ordering::Relaxed) {
-            panic!("InvalidStateError: recorder has already started")
-        }
+        let prev_active = self.inner.active.swap(true, Ordering::Relaxed);
+        assert!(
+            !prev_active,
+            "InvalidStateError - recorder has already started"
+        );
 
         let inner = Arc::clone(&self.inner);
         let blob = Vec::with_capacity(128 * 1024);

src/node/audio_buffer_source.rs

@@ -280,9 +280,10 @@ impl AudioBufferSourceNode {
     pub fn set_buffer(&mut self, audio_buffer: AudioBuffer) {
         let clone = audio_buffer.clone();
 
-        if self.buffer.is_some() {
-            panic!("InvalidStateError - cannot assign buffer twice");
-        }
+        assert!(
+            self.buffer.is_none(),
+            "InvalidStateError - cannot assign buffer twice",
+        );
         self.buffer = Some(audio_buffer);
 
         self.registration.post_message(clone);