Add http::Error::inner_ref and cause

src/error.rs

@@ -40,6 +40,31 @@ impl fmt::Display for Error {
     }
 }
 
+impl Error {
+    /// Return true if the underlying error has the same type as T.
+    pub fn is<T: error::Error + 'static>(&self) -> bool {
+        let ie = self.inner_ref();
+        ie.is::<T>()
+    }
+
+    /// Return a reference to the lower level, inner error.
+    pub fn inner_ref(&self) -> &(error::Error + 'static) {
+        use self::ErrorKind::*;
+
+        match self.inner {
+            StatusCode(ref e) => e,
+            Method(ref e) => e,
+            Uri(ref e) => e,
+            UriShared(ref e) => e,
+            UriParts(ref e) => e,
+            HeaderName(ref e) => e,
+            HeaderNameShared(ref e) => e,
+            HeaderValue(ref e) => e,
+            HeaderValueShared(ref e) => e,
+        }
+    }
+}
+
 impl error::Error for Error {
     fn description(&self) -> &str {
         use self::ErrorKind::*;
@@ -56,6 +81,10 @@ impl error::Error for Error {
             HeaderValueShared(ref e) => e.description(),
         }
     }
+
+    fn cause(&self) -> Option<&error::Error> {
+        Some(self.inner_ref())
+    }
 }
 
 impl From<status::InvalidStatusCode> for Error {
@@ -142,3 +171,23 @@ impl error::Error for Never {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn inner_error_is_invalid_status_code() {
+        if let Err(e) = status::StatusCode::from_u16(6666) {
+            let err: Error = e.into();
+            let ie = err.inner_ref();
+            assert!(!ie.is::<header::InvalidHeaderValue>());
+            assert!( ie.is::<status::InvalidStatusCode>());
+            ie.downcast_ref::<status::InvalidStatusCode>().unwrap();
+
+            assert!(!err.is::<header::InvalidHeaderValue>());
+            assert!( err.is::<status::InvalidStatusCode>());
+        } else {
+            panic!("Bad status allowed!");
+        }
+    }
+}