Merge pull request #10 from algesten/anyhow

Refactor out use of anyhow

Author: Rusty Rain

Cargo.toml

@@ -10,7 +10,6 @@ homepage = "https://webrtc.rs"
 repository = "https://github.com/webrtc-rs/rtcp"
 
 [dependencies]
-util = { package = "webrtc-util", version = "0.4.3", default-features = false, features = ["marshal"] }
+util = { package = "webrtc-util", version = "0.5.0", default-features = false, features = ["marshal"] }
 bytes = "1.1.0"
-thiserror = "1.0.29"
-anyhow = "1.0.44"
+thiserror = "1.0"

src/compound_packet/compound_packet_test.rs

@@ -58,8 +58,9 @@ fn test_bad_compound() {
 
         Err(err) => {
             let a = Error::BadFirstPacket;
-            assert!(
-                Error::BadFirstPacket.equal(&err),
+            assert_eq!(
+                Error::BadFirstPacket,
+                err,
                 "Unmarshal(badcompound) err={:?}, want {:?}",
                 err,
                 a,
@@ -150,7 +151,7 @@ fn test_valid_packet() {
             "goodbye",
             CompoundPacket(vec![
                 Box::new(ReceiverReport::default()),
-                Box::new(cname.clone()),
+                Box::new(cname),
                 Box::new(Goodbye::default()),
             ]),
             None,
@@ -161,13 +162,7 @@ fn test_valid_packet() {
         let result = packet.validate();
         assert_eq!(result.is_ok(), error.is_none());
         if let (Some(err), Err(got)) = (error, result) {
-            assert!(
-                err.equal(&got),
-                "Valid({}) = {:?}, want {:?}",
-                name,
-                got,
-                err
-            );
+            assert_eq!(err, got, "Valid({}) = {:?}, want {:?}", name, got, err);
         }
     }
 }
@@ -242,7 +237,7 @@ fn test_cname() {
             "goodbye",
             CompoundPacket(vec![
                 Box::new(ReceiverReport::default()),
-                Box::new(cname.clone()),
+                Box::new(cname),
                 Box::new(Goodbye::default()),
             ]),
             None,
@@ -254,13 +249,7 @@ fn test_cname() {
         let err = compound_packet.validate();
         assert_eq!(err.is_err(), want_error.is_some());
         if let (Some(want), Err(err)) = (&want_error, err) {
-            assert!(
-                want.equal(&err),
-                "Valid({}) = {:?}, want {:?}",
-                name,
-                err,
-                want
-            );
+            assert_eq!(*want, err, "Valid({}) = {:?}, want {:?}", name, err, want);
         }
 
         let name_result = compound_packet.cname();
@@ -273,13 +262,7 @@ fn test_cname() {
 
             Err(err) => {
                 if let Some(want) = &want_error {
-                    assert!(
-                        want.equal(&err),
-                        "CNAME({}) = {:?}, want {:?}",
-                        name,
-                        err,
-                        want
-                    );
+                    assert_eq!(*want, err, "CNAME({}) = {:?}, want {:?}", name, err, want);
                 }
             }
         }
@@ -303,7 +286,7 @@ fn test_compound_packet_roundtrip() {
             "goodbye",
             CompoundPacket(vec![
                 Box::new(ReceiverReport::default()),
-                Box::new(cname.clone()),
+                Box::new(cname),
                 Box::new(Goodbye {
                     sources: vec![1234],
                     ..Default::default()
@@ -322,12 +305,10 @@ fn test_compound_packet_roundtrip() {
         let result = packet.marshal();
         if let Some(err) = marshal_error {
             if let Err(got) = result {
-                assert!(
-                    err.equal(&got),
+                assert_eq!(
+                    err, got,
                     "marshal {} header: err = {}, want {}",
-                    name,
-                    got,
-                    err
+                    name, got, err
                 );
             } else {
                 assert!(false, "want error in test {}", name);
@@ -339,11 +320,11 @@ fn test_compound_packet_roundtrip() {
 
         let data1 = result.unwrap();
         let c = CompoundPacket::unmarshal(&mut data1.clone())
-            .expect(format!("unmarshal {} error", name).as_str());
+            .unwrap_or_else(|_| panic!("unmarshal {} error", name));
 
         let data2 = c
             .marshal()
-            .expect(format!("marshal {} error", name).as_str());
+            .unwrap_or_else(|_| panic!("marshal {} error", name));
 
         assert_eq!(
             data1, data2,

src/compound_packet/mod.rs

@@ -7,11 +7,12 @@ use crate::{
 };
 use util::marshal::{Marshal, MarshalSize, Unmarshal};
 
-use anyhow::Result;
 use bytes::{Buf, Bytes};
 use std::any::Any;
 use std::fmt;
 
+type Result<T> = std::result::Result<T, util::Error>;
+
 /// A CompoundPacket is a collection of RTCP packets transmitted as a single packet with
 /// the underlying protocol (for example UDP).
 ///

src/error.rs

@@ -1,6 +1,9 @@
 use thiserror::Error;
 
+pub type Result<T> = std::result::Result<T, Error>;
+
 #[derive(Error, Debug, PartialEq)]
+#[non_exhaustive]
 pub enum Error {
     /// Wrong marshal size.
     #[error("Wrong marshal size")]
@@ -86,13 +89,24 @@ pub enum Error {
     #[error("Packet status chunk must be 2 bytes")]
     PacketStatusChunkLength,
 
-    #[allow(non_camel_case_types)]
     #[error("{0}")]
-    new(String),
+    Util(#[from] util::Error),
+
+    #[error("{0}")]
+    Other(String),
+}
+
+impl From<Error> for util::Error {
+    fn from(e: Error) -> Self {
+        util::Error::from_std(e)
+    }
 }
 
-impl Error {
-    pub fn equal(&self, err: &anyhow::Error) -> bool {
-        err.downcast_ref::<Self>().map_or(false, |e| e == self)
+impl PartialEq<util::Error> for Error {
+    fn eq(&self, other: &util::Error) -> bool {
+        if let Some(down) = other.downcast_ref::<Error>() {
+            return self == down;
+        }
+        false
     }
 }

src/goodbye/goodbye_test.rs

@@ -117,12 +117,10 @@ fn test_goodbye_unmarshal() {
 
         if let Some(err) = want_error {
             let got_err = got.err().unwrap();
-            assert!(
-                err.equal(&got_err),
+            assert_eq!(
+                err, got_err,
                 "Unmarshal {} rr: err = {:?}, want {:?}",
-                name,
-                got_err,
-                err,
+                name, got_err, err,
             );
         } else {
             let actual = got.unwrap();
@@ -188,7 +186,7 @@ fn test_goodbye_round_trip() {
         (
             "count overflow",
             Goodbye {
-                sources: too_many_sources.clone(),
+                sources: too_many_sources,
                 reason: Bytes::from_static(b""),
             },
             Some(Error::TooManySources),
@@ -217,17 +215,15 @@ fn test_goodbye_round_trip() {
 
         if let Some(err) = want_error {
             let got_err = got.err().unwrap();
-            assert!(
-                err.equal(&got_err),
+            assert_eq!(
+                err, got_err,
                 "Unmarshal {} rr: err = {:?}, want {:?}",
-                name,
-                got_err,
-                err,
+                name, got_err, err,
             );
         } else {
             let mut data = got.ok().unwrap();
             let actual =
-                Goodbye::unmarshal(&mut data).expect(format!("Unmarshal {}", name).as_str());
+                Goodbye::unmarshal(&mut data).unwrap_or_else(|_| panic!("Unmarshal {}", name));
 
             assert_eq!(
                 actual, want,

src/goodbye/mod.rs

@@ -4,11 +4,12 @@ mod goodbye_test;
 use crate::{error::Error, header::*, packet::*, util::*};
 use util::marshal::{Marshal, MarshalSize, Unmarshal};
 
-use anyhow::Result;
 use bytes::{Buf, BufMut, Bytes};
 use std::any::Any;
 use std::fmt;
 
+type Result<T> = std::result::Result<T, util::Error>;
+
 /// The Goodbye packet indicates that one or more sources are no longer active.
 #[derive(Debug, PartialEq, Default, Clone)]
 pub struct Goodbye {

src/header.rs

@@ -1,7 +1,6 @@
 use crate::error::Error;
 use util::marshal::{Marshal, MarshalSize, Unmarshal};
 
-use anyhow::Result;
 use bytes::{Buf, BufMut};
 
 /// PacketType specifies the type of an RTCP packet
@@ -109,7 +108,7 @@ impl MarshalSize for Header {
 }
 
 impl Marshal for Header {
-    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
+    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize, util::Error> {
         if self.count > 31 {
             return Err(Error::InvalidHeader.into());
         }
@@ -138,7 +137,7 @@ impl Marshal for Header {
 
 impl Unmarshal for Header {
     /// Unmarshal decodes the Header from binary
-    fn unmarshal<B>(raw_packet: &mut B) -> Result<Self>
+    fn unmarshal<B>(raw_packet: &mut B) -> Result<Self, util::Error>
     where
         Self: Sized,
         B: Buf,
@@ -241,12 +240,10 @@ mod test {
 
             if let Some(err) = want_error {
                 let got_err = got.err().unwrap();
-                assert!(
-                    err.equal(&got_err),
+                assert_eq!(
+                    err, got_err,
                     "Unmarshal {}: err = {:?}, want {:?}",
-                    name,
-                    got_err,
-                    err,
+                    name, got_err, err,
                 );
             } else {
                 let actual = got.unwrap();
@@ -308,17 +305,16 @@ mod test {
 
             if let Some(err) = want_error {
                 let got_err = got.err().unwrap();
-                assert!(
-                    err.equal(&got_err),
+                assert_eq!(
+                    err, got_err,
                     "Unmarshal {} rr: err = {:?}, want {:?}",
-                    name,
-                    got_err,
-                    err,
+                    name, got_err, err,
                 );
             } else {
                 let data = got.ok().unwrap();
                 let buf = &mut data.clone();
-                let actual = Header::unmarshal(buf).expect(format!("Unmarshal {}", name).as_str());
+                let actual =
+                    Header::unmarshal(buf).unwrap_or_else(|_| panic!("Unmarshal {}", name));
 
                 assert_eq!(
                     actual, want,

src/lib.rs

@@ -41,7 +41,7 @@
 //!     // ...
 
 pub mod compound_packet;
-pub mod error;
+mod error;
 pub mod goodbye;
 pub mod header;
 pub mod packet;
@@ -53,3 +53,5 @@ pub mod sender_report;
 pub mod source_description;
 pub mod transport_feedbacks;
 mod util;
+
+pub use error::Error;

src/packet.rs

@@ -1,3 +1,4 @@
+use crate::error::Result;
 use crate::{
     compound_packet::*, error::Error, goodbye::*, header::*,
     payload_feedbacks::full_intra_request::*, payload_feedbacks::picture_loss_indication::*,
@@ -9,7 +10,6 @@ use crate::{
 };
 use util::marshal::{Marshal, Unmarshal};
 
-use anyhow::Result;
 use bytes::Buf;
 use std::any::Any;
 use std::fmt;
@@ -56,10 +56,10 @@ where
 
     match packets.len() {
         // Empty Packet
-        0 => Err(Error::InvalidHeader.into()),
+        0 => Err(Error::InvalidHeader),
 
         // Single Packet
-        1 => packets.pop().ok_or_else(|| Error::BadFirstPacket.into()),
+        1 => packets.pop().ok_or(Error::BadFirstPacket),
 
         // Compound Packet
         _ => Ok(Box::new(CompoundPacket(packets))),
@@ -76,7 +76,7 @@ where
 
     let length = (h.length as usize) * 4;
     if length > raw_data.remaining() {
-        return Err(Error::PacketTooShort.into());
+        return Err(Error::PacketTooShort);
     }
 
     let mut in_packet = h.marshal()?.chain(raw_data.take(length));
@@ -201,12 +201,7 @@ mod test {
         let result = unmarshal(&mut Bytes::new());
         if let Err(got) = result {
             let want = Error::InvalidHeader;
-            assert!(
-                want.equal(&got),
-                "Unmarshal(nil) err = {}, want {}",
-                got,
-                want
-            );
+            assert_eq!(want, got, "Unmarshal(nil) err = {}, want {}", got, want);
         } else {
             assert!(false, "want error");
         }
@@ -225,11 +220,10 @@ mod test {
         let result = unmarshal(&mut data);
         if let Err(got) = result {
             let want = Error::PacketTooShort;
-            assert!(
-                want.equal(&got),
+            assert_eq!(
+                want, got,
                 "Unmarshal(invalid_header_length) err = {}, want {}",
-                got,
-                want
+                got, want
             );
         } else {
             assert!(false, "want error");