Reject Unowned in register_port instead of panicking

Author: wmedrano

CHANGELOG.md

@@ -6,6 +6,8 @@
 - Added `Error::PortUnregistrationError`.
 - `Client::unregister_port` now returns `Err(Error::PortUnregistrationError)` on failure instead
   of `Err(Error::PortDisconnectionError)`.
+- `Client::register_port` with the `Unowned` spec now returns `Err(Error::PortRegistrationError)`.
+- `Unowned::jack_buffer_size` now returns `0` instead of panicking.
 
 ## 0.9.0
 

src/client/client_impl.rs

@@ -273,7 +273,7 @@ impl Client {
     /// Each port has a short name. The port's full name contains the name of the client
     /// concatenated with a colon (:) followed by its short name. `Port::name_size()` is the maximum
     /// length of the full name. Exceeding that will cause the port registration to fail and return
-    /// `Err(())`.
+    /// `Err(Error::PortRegistrationError)`.
     ///
     /// The `port_name` must be unique among all ports owned by this client. If the name is not
     /// unique, the registration will fail.
@@ -282,6 +282,10 @@ impl Client {
         port_name: &str,
         port_spec: PS,
     ) -> Result<Port<PS>, Error> {
+        // A port needs a type. This rejects `Unowned`, which only describes existing ports.
+        if port_spec.jack_port_type().is_empty() {
+            return Err(Error::PortRegistrationError(port_name.to_string()));
+        }
         let port_name_c = ffi::CString::new(port_name).unwrap();
         let port_type_c = ffi::CString::new(port_spec.jack_port_type()).unwrap();
         let port_flags = port_spec.jack_flags().bits();

src/port/port_impl.rs

@@ -343,23 +343,27 @@ impl<PS> Port<PS> {
 
 /// `PortSpec` for a port that holds has no readable or writeable data from JACK on the created
 /// client. It can be used to connect ports or to obtain metadata.
+///
+/// `Unowned` describes ports obtained with `Client::port_by_name` or `Client::port_by_id`. It
+/// cannot be used to register a port: `Client::register_port` returns
+/// `Err(Error::PortRegistrationError)`.
 #[derive(Debug, Default)]
 pub struct Unowned;
 
 unsafe impl PortSpec for Unowned {
-    /// Panics on call since the `Unowned` spec can't be used to create ports.
+    /// Empty, since the `Unowned` spec can't be used to create ports.
     fn jack_port_type(&self) -> &str {
         ""
     }
 
-    /// Panics on call since the `Unowned` spec can't be used to create ports.
+    /// Empty, since the `Unowned` spec can't be used to create ports.
     fn jack_flags(&self) -> PortFlags {
         PortFlags::empty()
     }
 
-    /// Panics on call since the `Unowned` spec can't be used to create ports.
+    /// Zero, since the `Unowned` spec can't be used to create ports.
     fn jack_buffer_size(&self) -> libc::c_ulong {
-        unreachable!()
+        0
     }
 }
 

src/tests/client.rs

@@ -101,3 +101,12 @@ fn unregistering_another_clients_port_is_an_unregistration_error() {
         Err(crate::Error::PortUnregistrationError)
     );
 }
+
+#[test]
+fn registering_an_unowned_port_is_an_error() {
+    let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
+    assert_eq!(
+        client.register_port("p", crate::Unowned).map(|_| ()),
+        Err(crate::Error::PortRegistrationError("p".to_string()))
+    );
+}