Small wording/naming changes; some missing tests (#15)

* HashMapAssertions::is_non_empty() failure wording

* test name

* same for HashSet

* same test rename for HashSet

* missing parens

* test name

* closing bracket

* test name

* test name

* same for vec

* same for ref vec

* separate tests for multiple should-panic's

* tests for vec not empty

Author: helixbass

src/hashmap.rs

@@ -93,8 +93,8 @@ where
 
         if subject.is_empty() {
             AssertionFailure::from_spec(self)
-                .with_expected("an non empty hashmap".to_string())
-                .with_actual(format!("a hashmap with length <{:?}>", subject.len()))
+                .with_expected("a non empty hashmap".to_string())
+                .with_actual("an empty hashmap".to_string())
                 .fail();
         }
     }
@@ -319,8 +319,8 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "\n\texpected: an non empty hashmap\
-                   \n\t but was: a hashmap with length <0>")]
+    #[should_panic(expected = "\n\texpected: a non empty hashmap\
+                   \n\t but was: an empty hashmap")]
     fn should_panic_if_hashmap_was_expected_to_not_be_empty_and_is() {
         let test_map: HashMap<u8, u8> = HashMap::new();
         assert_that(&test_map).is_not_empty();
@@ -348,7 +348,7 @@ mod tests {
     // Unfortunately the order of the keys can change. Doesn't seem to make sense to sort them
     // just for the sake of checking the panic message.
     #[should_panic]
-    fn should_not_panic_if_hashmap_does_not_contain_key() {
+    fn should_panic_if_hashmap_does_not_contain_key() {
         let mut test_map = HashMap::new();
         test_map.insert("hi", "hi");
         test_map.insert("hey", "hey");

src/hashset.rs

@@ -73,8 +73,8 @@ where
 
         if subject.is_empty() {
             AssertionFailure::from_spec(self)
-                .with_expected("an non empty HashSet".to_string())
-                .with_actual(format!("a HashSet with length <{:?}>", subject.len()))
+                .with_expected("a non empty HashSet".to_string())
+                .with_actual("an empty HashSet".to_string())
                 .fail();
         }
     }
@@ -130,8 +130,8 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "\n\texpected: an non empty HashSet\
-                   \n\t but was: a HashSet with length <0>")]
+    #[should_panic(expected = "\n\texpected: a non empty HashSet\
+                   \n\t but was: an empty HashSet")]
     fn should_panic_if_hash_set_was_expected_to_be_empty_and_is_not() {
         let test_map: HashSet<u8> = HashSet::new();
         assert_that(&test_map).is_not_empty();
@@ -159,7 +159,7 @@ mod tests {
     // Unfortunately the order of the keys can change. Doesn't seem to make sense to sort them
     // just for the sake of checking the panic message.
     #[should_panic]
-    fn should_not_panic_if_hash_set_does_not_contain() {
+    fn should_panic_if_hash_set_does_not_contain() {
         let mut test_map = HashSet::new();
         test_map.insert("hi");
         test_map.insert("hey");

src/iter.rs

@@ -364,7 +364,7 @@ where
                 AssertionFailure::from_spec(spec)
                     .with_expected(format!("Completed iterator (read <{:?}>)", read_expected))
                     .with_actual(format!(
-                        "Iterator item of <{:?}> (read <{:?}>",
+                        "Iterator item of <{:?}> (read <{:?}>)",
                         actual, read_subject
                     ))
                     .fail();
@@ -374,10 +374,10 @@ where
             (None, Some(expected)) => {
                 AssertionFailure::from_spec(spec)
                     .with_expected(format!(
-                        "Iterator item of <{:?}> (read <{:?}>",
+                        "Iterator item of <{:?}> (read <{:?}>)",
                         expected, read_expected
                     ))
-                    .with_actual(format!("Completed iterator (read <{:?}>", read_subject))
+                    .with_actual(format!("Completed iterator (read <{:?}>)", read_subject))
                     .fail();
 
                 unreachable!();

src/numeric.rs

@@ -176,7 +176,7 @@ mod tests {
     }
 
     #[test]
-    fn should_not_panic_if_value_is_less_than_or_equal_to_than_expected() {
+    fn should_not_panic_if_value_is_less_than_or_equal_to_expected() {
         assert_that(&2).is_less_than_or_equal_to(&2);
         assert_that(&2).is_less_than_or_equal_to(&3);
     }

src/option.rs

@@ -169,7 +169,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "\n\texpected: option[none]\n\t but was: option<\"Hello\"")]
+    #[should_panic(expected = "\n\texpected: option[none]\n\t but was: option<\"Hello\">")]
     fn should_panic_if_option_is_not_empty_but_was_expected_as_empty() {
         let option = Some("Hello");
         assert_that(&option).is_none();

src/result.rs

@@ -219,7 +219,7 @@ mod tests {
     }
 
     #[test]
-    fn should_not_panic_if_result_is_ok_with_uncomparable_ok() {
+    fn should_not_panic_if_result_is_ok_with_uncomparable_err() {
         #[derive(Debug)]
         struct Incomparable;
         let result: Result<&str, Incomparable> = Ok("Hello");

src/string.rs

@@ -207,7 +207,7 @@ mod tests {
     }
 
     #[test]
-    fn should_not_panic_if_str_does_not_contains_value() {
+    fn should_not_panic_if_str_does_not_contain_value() {
         let value = "Hello";
         assert_that(&value).does_not_contain("x");
     }

src/vec.rs

@@ -57,8 +57,8 @@ impl<T> VecAssertions for Spec<'_, Vec<T>> {
 
         if subject.is_empty() {
             AssertionFailure::from_spec(self)
-                .with_expected("an non empty vec".to_string())
-                .with_actual(format!("a vec with length {}", subject.len()))
+                .with_expected("a non empty vec".to_string())
+                .with_actual("an empty vec".to_string())
                 .fail();
         }
     }
@@ -113,8 +113,8 @@ impl<'s, T> VecAssertions for Spec<'s, &'s Vec<T>> {
 
         if subject.is_empty() {
             AssertionFailure::from_spec(self)
-                .with_expected("an non empty vec".to_string())
-                .with_actual(format!("a vec with length {}", subject.len()))
+                .with_expected("a non empty vec".to_string())
+                .with_actual("an empty vec".to_string())
                 .fail();
         }
     }
@@ -137,6 +137,12 @@ mod tests {
     fn should_panic_if_vec_length_does_not_match_expected() {
         let test_vec = vec![1, 2, 3];
         assert_that(&test_vec).has_length(1);
+    }
+
+    #[test]
+    #[should_panic(expected = "\n\texpected: vec to have length <1>\n\t but was: <3>")]
+    fn should_panic_if_ref_vec_length_does_not_match_expected() {
+        let test_vec = vec![1, 2, 3];
         assert_that(&&test_vec).has_length(1);
     }
 
@@ -152,6 +158,35 @@ mod tests {
                    \n\t but was: a vec with length <1>")]
     fn should_panic_if_vec_was_expected_to_be_empty_and_is_not() {
         assert_that(&vec![1]).is_empty();
+    }
+
+    #[test]
+    #[should_panic(expected = "\n\texpected: an empty vec\
+                   \n\t but was: a vec with length <1>")]
+    fn should_panic_if_ref_vec_was_expected_to_be_empty_and_is_not() {
         assert_that(&&vec![1]).is_empty();
     }
+
+    #[test]
+    fn should_not_panic_if_vec_was_expected_to_be_not_empty_and_is() {
+        let test_vec: Vec<u8> = vec![1];
+        assert_that(&test_vec).is_not_empty();
+        assert_that(&&test_vec).is_not_empty();
+    }
+
+    #[test]
+    #[should_panic(expected = "\n\texpected: a non empty vec\
+                   \n\t but was: an empty vec")]
+    fn should_panic_if_vec_was_expected_to_be_not_empty_and_is_not() {
+        let test_vec: Vec<u8> = vec![];
+        assert_that(&test_vec).is_not_empty();
+    }
+
+    #[test]
+    #[should_panic(expected = "\n\texpected: a non empty vec\
+                   \n\t but was: an empty vec")]
+    fn should_panic_if_ref_vec_was_expected_to_be_not_empty_and_is_not() {
+        let test_vec: Vec<u8> = vec![];
+        assert_that(&&test_vec).is_not_empty();
+    }
 }