Fix: Apply and remove clippy warnings

Author: jockbert

DOCUMENTATION.md

@@ -403,28 +403,28 @@ trait directly, or just make use of [shrink::from_fn].
 ## Key design principles of Monkey Test
 
 * *configurability and flexibility* - Leave a high degree of configurability
-   and flexibility to the user by letting most details to be specified
-   programatically. The aim is to have an declarative builder-style API like
-   the Java library
-   QuickTheories [(github)](https://github.com/quicktheories/QuickTheories).
+  and flexibility to the user by letting most details to be specified
+  programatically. The aim is to have an declarative builder-style API like
+  the Java library
+  QuickTheories [(github)](https://github.com/quicktheories/QuickTheories).
 
 * *powerful shinking* - Good shrinkers is a really important aspect of a
-   property based testing tool. Let say that the failing example is a vector
-   of 1000 elements and only 3 of the elements in combination is the actual
-   failure cause. You are then unlikely to find the 3-element combination,
-   if the shrinking is not powerful enough.
+  property based testing tool. Let say that the failing example is a vector
+  of 1000 elements and only 3 of the elements in combination is the actual
+  failure cause. You are then unlikely to find the 3-element combination,
+  if the shrinking is not powerful enough.
 
 * *composability for complex test examples* - Basic type generators and
-   shrinkers are provided out of the box.
-   User should also be able to genereate and shrink more complex types, by
-   composing together more primitive generators and shrinkers into more
-   complex ones.
-   The main inspiration here is the Scala library ScalaCheck
-   [(homepage)](https://scalacheck.org/),
-   which is fenomenal in this aspect, having the power to for example easily
-   generate and shrink recursive data structures, by using composition.
+  shrinkers are provided out of the box.
+  User should also be able to genereate and shrink more complex types, by
+  composing together more primitive generators and shrinkers into more
+  complex ones.
+  The main inspiration here is the Scala library ScalaCheck
+  [(homepage)](https://scalacheck.org/),
+  which is fenomenal in this aspect, having the power to for example easily
+  generate and shrink recursive data structures, by using composition.
 
 * *minimize macro magic* - In order to keep the tool simple, just avoid macros
-   if same developer experience can be provided using normal Rust code.
-   Macros-use is an complex escape hatch only to be used when normal syntax
-   is insufficient.
+  if same developer experience can be provided using normal Rust code.
+  Macros-use is an complex escape hatch only to be used when normal syntax
+  is insufficient.

src/runner.rs

@@ -94,7 +94,7 @@ where
                 do_shrink(prop, first_example.clone(), cg.gen.shrinker());
 
             // All but last shrinked value, up to a max limit
-            let other_count = shrinked_values.len().min(100).max(1) as u64 - 1;
+            let other_count = shrinked_values.len().clamp(1, 100) as u64 - 1;
             let some_other_failures = shrinked_values
                 .clone()
                 .into_iter()

src/shrink/integer.rs

@@ -144,7 +144,7 @@ fn shrink_target<E: PrimInt>(range_min: E, range_max: E) -> E {
 }
 
 /// Mirror a value `x` around the `mirror`, returning `2*mirror-x`, if possible
-/// witout overflow.  
+/// witout overflow.
 fn mirror_around<E: PrimInt>(mirror: E, x: E) -> Option<E> {
     let diff = x.saturating_sub(mirror);
     let x_mirrored = mirror.saturating_sub(diff);
@@ -273,7 +273,7 @@ mod test {
     #[test]
     fn eager_tries_iteratively_smaller_decrement_both_positive_and_negative() {
         assert_iter_eq(
-            super::eager(16, i64::min_value(), i64::max_value()),
+            super::eager(16, i64::MIN, i64::MAX),
             vec![8, -8, 12, -12, 14, -14],
             "shrinks toward zero, interleave positive and negative canidates \
             if not restricted by given range",
@@ -284,7 +284,7 @@ mod test {
     fn eager_tries_iteratively_smaller_decrement_with_positive_only_for_unsigned(
     ) {
         assert_iter_eq(
-            super::eager(16, u64::min_value(), u64::max_value()),
+            super::eager(16, u64::MIN, u64::MAX),
             vec![8, 12, 14],
             "shrinks toward zero, with only positive canidates for unsigned \
             integer typed",
@@ -294,26 +294,26 @@ mod test {
     #[test]
     fn eager_only_returns_candidates_within_range() {
         assert_iter_eq(
-            super::eager(16, -5, i64::max_value()),
+            super::eager(16, -5, i64::MAX),
             vec![8, 12, 14],
             "shrinks down toward zero, but only positives are in range",
         );
 
         assert_iter_eq(
-            super::eager(17, 1, i64::max_value()),
+            super::eager(17, 1, i64::MAX),
             vec![9, 13, 15],
             "shrink as in first but translated 1 to rateger 1 from 17, so \
             difference from original_failure to target is still 16",
         );
 
         assert_iter_eq(
-            super::eager(-16, i64::min_value(), 5),
+            super::eager(-16, i64::MIN, 5),
             vec![-8, -12, -14],
             "same shrinking as in first assert, but only negative are in range."
         );
 
         assert_iter_eq(
-            super::eager(16, -12, i64::max_value()),
+            super::eager(16, -12, i64::MAX),
             vec![8, -8, 12, -12, 14],
             "same shrinking as in first assert, but some (!) negative are in range."
         );
@@ -326,6 +326,6 @@ mod test {
     #[test]
     #[should_panic = "Given example 1337 is not in range 0..=16."]
     fn eager_with_example_out_of_range_should_panic() {
-        let _ = super::eager(1337, u64::min_value(), 16);
+        let _ = super::eager(1337, u64::MIN, 16);
     }
 }

src/shrink/vec.rs

@@ -94,7 +94,7 @@ impl<E> EagerIterator<E> {
         self.len_to_remove = match self.len_to_remove {
             usize::MAX => usize::MAX / 2,
             1 => 0,
-            _ => (self.len_to_remove + 1) / 2,
+            _ => self.len_to_remove.div_ceil(2),
         }
     }
 

src/testing/integer.rs

@@ -20,7 +20,7 @@ pub fn assert_even_distr<E>(
 
     let expected_range = (expected_max - expected_min + E::one())
         .to_usize()
-        .unwrap_or(usize::max_value());
+        .unwrap_or(usize::MAX);
 
     // Pick so many elements such there should be roughly x instances of
     // each value.

tests/basic_usage.rs

@@ -85,6 +85,10 @@ fn can_assert_eq() {
         .assert_eq(|n| n, |n| n / 2 * 2);
 }
 
+/// Shows how to test for the proper of values being not equal, here shown as a
+/// faulty property due to positive odd numbers divided by two are rounded down.
+///
+/// Here for n=0, both 2/2=1 and 3/2=1.
 #[test]
 #[should_panic(
     expected = "Reason: Actual value should not equal expected 1, but got 1."
@@ -93,7 +97,7 @@ fn can_assert_ne() {
     monkey_test()
         .with_example_count(1_000)
         .with_generator(gen::u32::ranged(0..10_000))
-        .assert_ne(|n| (n + 1) / 2, |n| (n + 2) / 2);
+        .assert_ne(|n| (n + 2) / 2, |n| (n + 3) / 2);
 }
 
 #[test]