Merge pull request #27 from zummenix/patch_3

Reimplement the be_empty matcher using Iterator.

README.md

@@ -91,12 +91,10 @@ expect!("4".parse::<u32>()).to(be_ok().value(4));
 Use any of the following matchers: `be_ok`, `be_err`
 
 #### Emptyness
-There is `be_empty` matcher for types that implement `IsEmpty` trait:
+There is `be_empty` matcher for types that implement `Iterator + Clone` trait:
 ```rust
-expect!("").to(be_empty());
+expect!("".chars()).to(be_empty());
 ```
-> Note: `IsEmpty` trait implemented by library for following types:
-`String`, `&str`, `Vec<T>`, `&[T]`.
 
 #### Count of elements in a collection
 There is `have_count` matcher for types that implement `Iterator + Clone` trait:

src/lib.rs

@@ -24,4 +24,3 @@ pub mod prelude {
 
 pub mod core;
 pub mod matchers;
-pub mod traits;

src/matchers/empty.rs

@@ -1,7 +1,5 @@
 
-use std::fmt;
 use core::{Matcher, Join};
-use traits::IsEmpty;
 
 /// A matcher for `be_empty` assertions.
 pub struct BeEmpty;
@@ -11,17 +9,18 @@ pub fn be_empty() -> BeEmpty {
     BeEmpty
 }
 
-impl<A> Matcher<A, ()> for BeEmpty where A: IsEmpty + fmt::Debug {
+impl<A, T> Matcher<A, ()> for BeEmpty where A: Iterator<Item = T> + Clone {
     fn failure_message(&self, join: Join, actual: &A) -> String {
         if join.is_assertion() {
-            format!("expected {} be empty, got <{:?}>", join, actual)
+            let count = actual.clone().count();
+            format!("expected {} be empty, got the length of {}", join, count)
         } else {
             format!("expected {} be empty", join)
         }
     }
 
     fn matches(&self, actual: &A) -> bool {
-        actual.is_empty()
+        actual.clone().count() == 0
     }
 }
 
@@ -32,14 +31,14 @@ mod tests {
 
     #[test]
     fn be_empty_str_failure_message() {
-        expect("hello")
+        expect("hello".chars())
             .to(be_empty())
-            .assert_eq_message("expected to be empty, got <\"hello\">");
+            .assert_eq_message("expected to be empty, got the length of 5");
     }
 
     #[test]
     fn to_not_be_empty_str_failure_message() {
-        expect("")
+        expect("".chars())
             .to_not(be_empty())
             .assert_eq_message("expected to not be empty");
     }

tests/empty.rs

@@ -3,50 +3,26 @@
 extern crate expectest;
 use expectest::prelude::*;
 
-#[test]
-fn emptiness_of_string() {
-    expect!("".to_string()).to(be_empty());
-}
-
 #[test]
 fn emptiness_of_str() {
-    expect!("").to(be_empty());
-}
-
-#[test]
-#[should_panic]
-fn emptiness_of_string_should_panic() {
-    expect!("s".to_string()).to(be_empty());
+    expect!("".chars()).to(be_empty());
 }
 
 #[test]
 #[should_panic]
 fn emptiness_of_str_should_panic() {
-    expect!("world").to(be_empty());
+    expect!("world".chars()).to(be_empty());
 }
 
 #[test]
 fn emptiness_of_vec() {
     let v: Vec<u32> = vec![];
-    expect!(v).to(be_empty());
-}
-
-#[test]
-fn emptiness_of_array() {
-    let v: &[u32] = &[];
-    expect!(v).to(be_empty());
+    expect!(v.iter()).to(be_empty());
 }
 
 #[test]
 #[should_panic]
 fn emptiness_of_vec_should_panic() {
     let v = vec![1, 2];
-    expect!(v).to(be_empty());
-}
-
-#[test]
-#[should_panic]
-fn emptiness_of_array_should_panic() {
-    let v: &[u32] = &[1, 2];
-    expect!(v).to(be_empty());
+    expect!(v.iter()).to(be_empty());
 }