chore: run cargo fmt

Author: haraldmaida

src/bigdecimal/tests.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
-use bigdecimal::num_bigint::BigInt;
 use bigdecimal::BigDecimal;
+use bigdecimal::num_bigint::BigInt;
 
 #[test]
 fn bigdecimal_is_equal_to_other() {

src/boolean/mod.rs

@@ -2,7 +2,7 @@
 
 use crate::assertions::AssertBoolean;
 use crate::colored::{mark_missing, mark_unexpected};
-use crate::expectations::{is_false, is_true, IsFalse, IsTrue};
+use crate::expectations::{IsFalse, IsTrue, is_false, is_true};
 use crate::spec::{DiffFormat, Expectation, Expression, FailingStrategy, Invertible, Spec};
 use crate::std::format;
 use crate::std::string::String;

src/char/mod.rs

@@ -1,9 +1,9 @@
 use crate::assertions::AssertChar;
 use crate::colored::{mark_missing_string, mark_unexpected_char};
 use crate::expectations::{
-    is_alphabetic, is_alphanumeric, is_ascii, is_control_char, is_digit, is_lower_case,
-    is_upper_case, is_whitespace, IsAlphabetic, IsAlphanumeric, IsAscii, IsControlChar, IsDigit,
-    IsLowerCase, IsUpperCase, IsWhitespace,
+    IsAlphabetic, IsAlphanumeric, IsAscii, IsControlChar, IsDigit, IsLowerCase, IsUpperCase,
+    IsWhitespace, is_alphabetic, is_alphanumeric, is_ascii, is_control_char, is_digit,
+    is_lower_case, is_upper_case, is_whitespace,
 };
 use crate::spec::{DiffFormat, Expectation, Expression, FailingStrategy, Invertible, Spec};
 use crate::std::format;
@@ -102,7 +102,9 @@ impl Expectation<char> for IsLowerCase {
         };
         let marked_actual = mark_unexpected_char(*actual, format);
         let marked_expected = mark_missing_string(&expected, format);
-        format!("expected {expression} to be {not}lowercase\n   but was: {marked_actual}\n  expected: {marked_expected}")
+        format!(
+            "expected {expression} to be {not}lowercase\n   but was: {marked_actual}\n  expected: {marked_expected}"
+        )
     }
 }
 
@@ -143,7 +145,9 @@ impl Expectation<char> for IsUpperCase {
         };
         let marked_actual = mark_unexpected_char(*actual, format);
         let marked_expected = mark_missing_string(&expected, format);
-        format!("expected {expression} to be {not}uppercase\n   but was: {marked_actual}\n  expected: {marked_expected}")
+        format!(
+            "expected {expression} to be {not}uppercase\n   but was: {marked_actual}\n  expected: {marked_expected}"
+        )
     }
 }
 
@@ -179,7 +183,9 @@ impl Expectation<char> for IsAscii {
     ) -> String {
         let not = if inverted { "not " } else { "" };
         let marked_actual = mark_unexpected_char(*actual, format);
-        format!("expected {expression} to be {not}an ASCII character\n   but was: {marked_actual}\n  expected: {not}an ASCII character")
+        format!(
+            "expected {expression} to be {not}an ASCII character\n   but was: {marked_actual}\n  expected: {not}an ASCII character"
+        )
     }
 }
 
@@ -215,7 +221,9 @@ impl Expectation<char> for IsAlphabetic {
     ) -> String {
         let not = if inverted { "not " } else { "" };
         let marked_actual = mark_unexpected_char(*actual, format);
-        format!("expected {expression} to be {not}an alphabetic character\n   but was: {marked_actual}\n  expected: {not}an alphabetic character")
+        format!(
+            "expected {expression} to be {not}an alphabetic character\n   but was: {marked_actual}\n  expected: {not}an alphabetic character"
+        )
     }
 }
 
@@ -251,7 +259,9 @@ impl Expectation<char> for IsAlphanumeric {
     ) -> String {
         let not = if inverted { "not " } else { "" };
         let marked_actual = mark_unexpected_char(*actual, format);
-        format!("expected {expression} to be {not}an alphanumeric character\n   but was: {marked_actual}\n  expected: {not}an alphanumeric character")
+        format!(
+            "expected {expression} to be {not}an alphanumeric character\n   but was: {marked_actual}\n  expected: {not}an alphanumeric character"
+        )
     }
 }
 
@@ -287,7 +297,9 @@ impl Expectation<char> for IsControlChar {
     ) -> String {
         let not = if inverted { "not " } else { "" };
         let marked_actual = mark_unexpected_char(*actual, format);
-        format!("expected {expression} to be {not}a control character\n   but was: {marked_actual}\n  expected: {not}a control character")
+        format!(
+            "expected {expression} to be {not}a control character\n   but was: {marked_actual}\n  expected: {not}a control character"
+        )
     }
 }
 
@@ -324,7 +336,9 @@ impl Expectation<char> for IsDigit {
         let not = if inverted { "not " } else { "" };
         let radix = self.radix;
         let marked_actual = mark_unexpected_char(*actual, format);
-        format!("expected {expression} to be {not}a digit in the radix {radix}\n   but was: {marked_actual}\n  expected: {not}a digit in the radix {radix}")
+        format!(
+            "expected {expression} to be {not}a digit in the radix {radix}\n   but was: {marked_actual}\n  expected: {not}a digit in the radix {radix}"
+        )
     }
 }
 
@@ -360,7 +374,9 @@ impl Expectation<char> for IsWhitespace {
     ) -> String {
         let not = if inverted { "not " } else { "" };
         let marked_actual = mark_unexpected_char(*actual, format);
-        format!("expected {expression} to be {not}whitespace\n   but was: {marked_actual}\n  expected: {not}whitespace")
+        format!(
+            "expected {expression} to be {not}whitespace\n   but was: {marked_actual}\n  expected: {not}whitespace"
+        )
     }
 }
 

src/char_count.rs

@@ -3,9 +3,9 @@
 use crate::assertions::AssertHasCharCount;
 use crate::colored::{mark_missing, mark_unexpected};
 use crate::expectations::{
-    has_at_least_char_count, has_at_most_char_count, has_char_count, has_char_count_greater_than,
-    has_char_count_in_range, has_char_count_less_than, HasAtLeastCharCount, HasAtMostCharCount,
-    HasCharCount, HasCharCountGreaterThan, HasCharCountInRange, HasCharCountLessThan,
+    HasAtLeastCharCount, HasAtMostCharCount, HasCharCount, HasCharCountGreaterThan,
+    HasCharCountInRange, HasCharCountLessThan, has_at_least_char_count, has_at_most_char_count,
+    has_char_count, has_char_count_greater_than, has_char_count_in_range, has_char_count_less_than,
 };
 use crate::properties::CharCountProperty;
 use crate::spec::{DiffFormat, Expectation, Expression, FailingStrategy, Spec};

src/collection.rs

@@ -2,8 +2,8 @@
 
 use crate::properties::{DefinedOrderProperty, IsEmptyProperty, LengthProperty};
 use crate::std::collections::{
-    btree_map, btree_set, linked_list, vec_deque, BTreeMap, BTreeSet, BinaryHeap, LinkedList,
-    VecDeque,
+    BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque, btree_map, btree_set, linked_list,
+    vec_deque,
 };
 use crate::std::{array, slice};
 use crate::std::{vec, vec::Vec};

src/colored/mod.rs

@@ -47,8 +47,8 @@
 #[cfg(feature = "colored")]
 #[cfg_attr(docsrs, doc(cfg(feature = "colored")))]
 pub use with_colored_feature::{
-    diff_format_for_mode, DIFF_FORMAT_BOLD, DIFF_FORMAT_RED_BLUE, DIFF_FORMAT_RED_GREEN,
-    DIFF_FORMAT_RED_YELLOW,
+    DIFF_FORMAT_BOLD, DIFF_FORMAT_RED_BLUE, DIFF_FORMAT_RED_GREEN, DIFF_FORMAT_RED_YELLOW,
+    diff_format_for_mode,
 };
 
 use crate::spec::{DiffFormat, Highlight};

src/colored/tests.rs

@@ -59,12 +59,15 @@ mod with_colored_feature {
             }))
             .display_failures();
 
-        assert_eq!(failures, &[
-            "expected subject to be equal to Some(Foo { lorem: \"Hello World!\", ipsum: 42, dolor: Some(\"hey ho!\") })\n   \
+        assert_eq!(
+            failures,
+            &[
+                "expected subject to be equal to Some(Foo { lorem: \"Hello World!\", ipsum: 42, dolor: Some(\"hey ho!\") })\n   \
                  but was: Some(Foo { lorem: \"\u{1b}[31m¡\u{1b}[0mH\u{1b}[31mo\u{1b}[0ml\u{1b}[31ma,\u{1b}[0m W\u{1b}[31me\u{1b}[0ml\u{1b}[31mt\u{1b}[0m!\", ipsum: 42, dolor: Some(\"hey\") })\n  \
                expected: Some(Foo { lorem: \"H\u{1b}[32me\u{1b}[0ml\u{1b}[32mlo\u{1b}[0m W\u{1b}[32mor\u{1b}[0ml\u{1b}[32md\u{1b}[0m!\", ipsum: 42, dolor: Some(\"hey\u{1b}[32m ho!\u{1b}[0m\") })\n\
             ",
-        ]);
+            ]
+        );
     }
 
     #[test]
@@ -136,8 +139,8 @@ mod with_colored_feature {
     }
 
     #[test]
-    fn mark_unexpected_substring_in_string_highlights_nothing_if_the_string_does_not_contain_the_substring(
-    ) {
+    fn mark_unexpected_substring_in_string_highlights_nothing_if_the_string_does_not_contain_the_substring()
+     {
         let marked_string = mark_unexpected_substring_in_string(
             "mollit est eu amet",
             "st eux a",
@@ -159,8 +162,8 @@ mod with_colored_feature {
     }
 
     #[test]
-    fn mark_missing_substring_in_string_highlights_nothing_if_the_string_does_not_contain_the_substring(
-    ) {
+    fn mark_missing_substring_in_string_highlights_nothing_if_the_string_does_not_contain_the_substring()
+     {
         let marked_string = mark_missing_substring_in_string(
             "mollit est eu amet",
             "xt est eu",
@@ -171,8 +174,8 @@ mod with_colored_feature {
     }
 
     #[test]
-    fn mark_unexpected_char_in_string_highlights_all_occurences_of_a_char_within_a_string_as_unexpected(
-    ) {
+    fn mark_unexpected_char_in_string_highlights_all_occurences_of_a_char_within_a_string_as_unexpected()
+     {
         let marked_string =
             mark_unexpected_char_in_string("zzril mazim sint", 'z', &DIFF_FORMAT_RED_YELLOW);
 
@@ -181,8 +184,8 @@ mod with_colored_feature {
     }
 
     #[test]
-    fn mark_unexpected_char_in_string_highlights_nothing_if_the_string_does_not_contain_the_character(
-    ) {
+    fn mark_unexpected_char_in_string_highlights_nothing_if_the_string_does_not_contain_the_character()
+     {
         let marked_string =
             mark_unexpected_char_in_string("zzril mazim sint", 'v', &DIFF_FORMAT_RED_YELLOW);
 

src/equality.rs

@@ -5,8 +5,8 @@ use crate::assertions::{
 };
 use crate::colored::{mark_diff, mark_diff_str};
 use crate::expectations::{
-    has_debug_string, has_display_string, is_equal_to, is_same_as, not, HasDebugString,
-    HasDisplayString, IsEqualTo, IsSameAs,
+    HasDebugString, HasDisplayString, IsEqualTo, IsSameAs, has_debug_string, has_display_string,
+    is_equal_to, is_same_as, not,
 };
 use crate::spec::{DiffFormat, Expectation, Expression, FailingStrategy, Invertible, Spec};
 use crate::std::fmt::{Debug, Display};

src/error/mod.rs

@@ -1,7 +1,7 @@
 use crate::assertions::AssertErrorHasSource;
 use crate::colored::{mark_missing, mark_missing_string, mark_unexpected, mark_unexpected_string};
 use crate::expectations::{
-    error_has_source, error_has_source_message, not, ErrorHasSource, ErrorHasSourceMessage,
+    ErrorHasSource, ErrorHasSourceMessage, error_has_source, error_has_source_message, not,
 };
 use crate::spec::{DiffFormat, Expectation, Expression, FailingStrategy, Invertible, Spec};
 use crate::std::error::Error;
@@ -52,7 +52,9 @@ where
         };
         let marked_actual = mark_unexpected(actual, format);
         let marked_expected = mark_missing_string(expected, format);
-        format!("expected {expression} to have {a} source\n   but was: {marked_actual}\n  expected: {marked_expected}")
+        format!(
+            "expected {expression} to have {a} source\n   but was: {marked_actual}\n  expected: {marked_expected}"
+        )
     }
 }
 
@@ -80,12 +82,16 @@ where
         if let Some(actual_source) = actual.source() {
             let marked_actual = mark_unexpected_string(&actual_source.to_string(), format);
             let marked_expected = mark_missing_string(expected, format);
-            format!("expected {expression} to have a source message {not}equal to \"{expected}\"\n   but was: \"{marked_actual}\"\n  expected: \"{marked_expected}\"")
+            format!(
+                "expected {expression} to have a source message {not}equal to \"{expected}\"\n   but was: \"{marked_actual}\"\n  expected: \"{marked_expected}\""
+            )
         } else {
             let mut marked_actual = mark_unexpected(actual, format);
             marked_actual.push_str(" - which has no source");
             let marked_expected = mark_missing(expected, format);
-            format!("expected {expression} to have a source message {not}equal to \"{expected}\"\n   but was: {marked_actual}\n  expected: {not}{marked_expected}")
+            format!(
+                "expected {expression} to have a source message {not}equal to \"{expected}\"\n   but was: {marked_actual}\n  expected: {not}{marked_expected}"
+            )
         }
     }
 }

src/expectation_combinators/tests.rs

@@ -1,6 +1,6 @@
 use crate::expectations::{
-    all, any, not, rec, IsBetween, IsEmpty, IsGreaterThan, IsLessThan, IsNegative, IsOne,
-    IsPositive, IsZero, StringContains, StringContainsAnyOf,
+    IsBetween, IsEmpty, IsGreaterThan, IsLessThan, IsNegative, IsOne, IsPositive, IsZero,
+    StringContains, StringContainsAnyOf, all, any, not, rec,
 };
 use crate::prelude::*;
 use crate::spec::{Expectation, Expression};