Fix/silence various clippy warnings in test code.

Didn't realize there was an easy way to run clippy on tests.
Thanks to @LittleTasteOfHeaven for making me aware!

Author: cessen

examples/graphemes_iter.rs

@@ -2,6 +2,7 @@
 //! of a `Rope` or `RopeSlice`.  This also serves as a good starting point for
 //! iterators for other kinds of segementation, such as word boundaries.
 
+#![allow(clippy::redundant_field_names)]
 #![allow(dead_code)]
 
 extern crate ropey;

examples/search_and_replace.rs

@@ -7,6 +7,8 @@
 //! The file contents with the search-and-replace performed on it is sent to
 //! stdout.
 
+#![allow(clippy::redundant_field_names)]
+
 extern crate ropey;
 
 use std::fs::File;
@@ -83,8 +85,7 @@ fn search_and_replace(rope: &mut Rope, search_pattern: &str, replacement_text: &
         // `Iterator::collect()` to collect the batch because we want to
         // re-use the same Vec to avoid unnecessary allocations.
         matches.clear();
-        for m in SearchIter::from_rope_slice(&rope.slice(head..), &search_pattern).take(BATCH_SIZE)
-        {
+        for m in SearchIter::from_rope_slice(&rope.slice(head..), search_pattern).take(BATCH_SIZE) {
             matches.push(m);
         }
 
@@ -102,7 +103,7 @@ fn search_and_replace(rope: &mut Rope, search_pattern: &str, replacement_text: &
 
             // Do the replacement.
             rope.remove(start_d..end_d);
-            rope.insert(start_d, &replacement_text);
+            rope.insert(start_d, replacement_text);
 
             // Update the index offset.
             let match_len = (end - start) as isize;
@@ -153,6 +154,7 @@ impl<'a> Iterator for SearchIter<'a> {
 
     // Return the start/end char indices of the next match.
     fn next(&mut self) -> Option<(usize, usize)> {
+        #[allow(clippy::while_let_on_iterator)]
         while let Some(next_char) = self.char_iter.next() {
             self.cur_index += 1;
 

examples/simple_buffer.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::redundant_field_names)]
 #![allow(dead_code)]
 
 extern crate ropey;
@@ -24,23 +25,23 @@ impl TextBuffer {
         })
     }
 
-    fn get_line<'a>(&'a self, idx: usize) -> RopeSlice<'a> {
+    fn get_line(&self, idx: usize) -> RopeSlice {
         self.text.line(idx)
     }
 
-    fn bytes<'a>(&'a self) -> Bytes<'a> {
+    fn bytes(&self) -> Bytes {
         self.text.bytes()
     }
 
-    fn chars<'a>(&'a self) -> Chars<'a> {
+    fn chars(&self) -> Chars {
         self.text.chars()
     }
 
-    fn lines<'a>(&'a self) -> Lines<'a> {
+    fn lines(&self) -> Lines {
         self.text.lines()
     }
 
-    fn chunks<'a>(&'a self) -> Chunks<'a> {
+    fn chunks(&self) -> Chunks {
         self.text.chunks()
     }
 

src/iter.rs

@@ -1368,6 +1368,7 @@ impl<'a> Iterator for Chunks<'a> {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::while_let_on_iterator)]
     use super::*;
     use crate::Rope;
 

src/rope.rs

@@ -2367,7 +2367,8 @@ mod tests {
     #[should_panic]
     fn remove_06() {
         let mut r = Rope::from_str(TEXT);
-        r.remove(56..55); // Wrong ordering of start/end
+        #[allow(clippy::reversed_empty_ranges)]
+        r.remove(56..55); // Wrong ordering of start/end on purpose.
     }
 
     #[test]
@@ -3152,7 +3153,8 @@ mod tests {
     #[should_panic]
     fn slice_05() {
         let r = Rope::from_str(TEXT);
-        r.slice(53..52);
+        #[allow(clippy::reversed_empty_ranges)]
+        r.slice(53..52); // Wrong ordering on purpose.
     }
 
     #[test]
@@ -3202,7 +3204,8 @@ mod tests {
     #[should_panic]
     fn byte_slice_05() {
         let r = Rope::from_str(TEXT);
-        r.byte_slice(53..52);
+        #[allow(clippy::reversed_empty_ranges)]
+        r.byte_slice(53..52); // Wrong ordering on purpose.
     }
 
     #[test]

src/slice.rs

@@ -2759,7 +2759,8 @@ mod tests {
         let r = Rope::from_str(TEXT);
         let s = r.slice(5..43);
 
-        s.slice(21..20);
+        #[allow(clippy::reversed_empty_ranges)]
+        s.slice(21..20); // Wrong ordering on purpose.
     }
 
     #[test]
@@ -2828,7 +2829,8 @@ mod tests {
         let r = Rope::from_str(TEXT);
         let s = r.byte_slice(50..118);
 
-        s.byte_slice(21..20);
+        #[allow(clippy::reversed_empty_ranges)]
+        s.byte_slice(21..20); // Wrong ordering on purpose.
     }
 
     #[test]

src/str_utils.rs

@@ -207,60 +207,60 @@ mod tests {
 
     #[test]
     fn ends_with_line_break_01() {
-        assert_eq!(true, ends_with_line_break("\n"));
+        assert!(ends_with_line_break("\n"));
 
         #[cfg(any(feature = "cr_lines", feature = "unicode_lines"))]
-        assert_eq!(true, ends_with_line_break("\r"));
+        assert!(ends_with_line_break("\r"));
 
         #[cfg(feature = "unicode_lines")]
         {
-            assert_eq!(true, ends_with_line_break("\u{000A}"));
-            assert_eq!(true, ends_with_line_break("\u{000B}"));
-            assert_eq!(true, ends_with_line_break("\u{000C}"));
-            assert_eq!(true, ends_with_line_break("\u{000D}"));
-            assert_eq!(true, ends_with_line_break("\u{0085}"));
-            assert_eq!(true, ends_with_line_break("\u{2028}"));
-            assert_eq!(true, ends_with_line_break("\u{2029}"));
+            assert!(ends_with_line_break("\u{000A}"));
+            assert!(ends_with_line_break("\u{000B}"));
+            assert!(ends_with_line_break("\u{000C}"));
+            assert!(ends_with_line_break("\u{000D}"));
+            assert!(ends_with_line_break("\u{0085}"));
+            assert!(ends_with_line_break("\u{2028}"));
+            assert!(ends_with_line_break("\u{2029}"));
         }
     }
 
     #[test]
     fn ends_with_line_break_02() {
-        assert_eq!(true, ends_with_line_break("Hi there!\n"));
+        assert!(ends_with_line_break("Hi there!\n"));
 
         #[cfg(any(feature = "cr_lines", feature = "unicode_lines"))]
-        assert_eq!(true, ends_with_line_break("Hi there!\r"));
+        assert!(ends_with_line_break("Hi there!\r"));
 
         #[cfg(feature = "unicode_lines")]
         {
-            assert_eq!(true, ends_with_line_break("Hi there!\u{000A}"));
-            assert_eq!(true, ends_with_line_break("Hi there!\u{000B}"));
-            assert_eq!(true, ends_with_line_break("Hi there!\u{000C}"));
-            assert_eq!(true, ends_with_line_break("Hi there!\u{000D}"));
-            assert_eq!(true, ends_with_line_break("Hi there!\u{0085}"));
-            assert_eq!(true, ends_with_line_break("Hi there!\u{2028}"));
-            assert_eq!(true, ends_with_line_break("Hi there!\u{2029}"));
+            assert!(ends_with_line_break("Hi there!\u{000A}"));
+            assert!(ends_with_line_break("Hi there!\u{000B}"));
+            assert!(ends_with_line_break("Hi there!\u{000C}"));
+            assert!(ends_with_line_break("Hi there!\u{000D}"));
+            assert!(ends_with_line_break("Hi there!\u{0085}"));
+            assert!(ends_with_line_break("Hi there!\u{2028}"));
+            assert!(ends_with_line_break("Hi there!\u{2029}"));
         }
     }
 
     #[test]
     fn ends_with_line_break_03() {
-        assert_eq!(false, ends_with_line_break(""));
-        assert_eq!(false, ends_with_line_break("a"));
-        assert_eq!(false, ends_with_line_break("Hi there!"));
+        assert!(!ends_with_line_break(""));
+        assert!(!ends_with_line_break("a"));
+        assert!(!ends_with_line_break("Hi there!"));
     }
 
     #[test]
     fn ends_with_line_break_04() {
-        assert_eq!(false, ends_with_line_break("\na"));
-        assert_eq!(false, ends_with_line_break("\ra"));
-        assert_eq!(false, ends_with_line_break("\u{000A}a"));
-        assert_eq!(false, ends_with_line_break("\u{000B}a"));
-        assert_eq!(false, ends_with_line_break("\u{000C}a"));
-        assert_eq!(false, ends_with_line_break("\u{000D}a"));
-        assert_eq!(false, ends_with_line_break("\u{0085}a"));
-        assert_eq!(false, ends_with_line_break("\u{2028}a"));
-        assert_eq!(false, ends_with_line_break("\u{2029}a"));
+        assert!(!ends_with_line_break("\na"));
+        assert!(!ends_with_line_break("\ra"));
+        assert!(!ends_with_line_break("\u{000A}a"));
+        assert!(!ends_with_line_break("\u{000B}a"));
+        assert!(!ends_with_line_break("\u{000C}a"));
+        assert!(!ends_with_line_break("\u{000D}a"));
+        assert!(!ends_with_line_break("\u{0085}a"));
+        assert!(!ends_with_line_break("\u{2028}a"));
+        assert!(!ends_with_line_break("\u{2029}a"));
     }
 
     #[test]

src/tree/node.rs

@@ -1023,16 +1023,11 @@ mod tests {
     fn crlf_corner_case_01() {
         use super::Node;
         use crate::tree::{NodeChildren, NodeText, MAX_BYTES};
-        use std::iter;
         use std::sync::Arc;
 
         // Construct the corner case
-        let nodel = Node::Leaf(NodeText::from_str(
-            &iter::repeat("\n").take(MAX_BYTES - 1).collect::<String>(),
-        ));
-        let noder = Node::Leaf(NodeText::from_str(
-            &iter::repeat("\n").take(MAX_BYTES).collect::<String>(),
-        ));
+        let nodel = Node::Leaf(NodeText::from_str(&"\n".repeat(MAX_BYTES - 1)));
+        let noder = Node::Leaf(NodeText::from_str(&"\n".repeat(MAX_BYTES)));
         let mut children = NodeChildren::new();
         children.push((nodel.text_info(), Arc::new(nodel)));
         children.push((noder.text_info(), Arc::new(noder)));
@@ -1051,16 +1046,11 @@ mod tests {
     fn crlf_corner_case_02() {
         use super::Node;
         use crate::tree::{NodeChildren, NodeText, MAX_BYTES};
-        use std::iter;
         use std::sync::Arc;
 
         // Construct the corner case
-        let nodel = Node::Leaf(NodeText::from_str(
-            &iter::repeat("\r").take(MAX_BYTES).collect::<String>(),
-        ));
-        let noder = Node::Leaf(NodeText::from_str(
-            &iter::repeat("\r").take(MAX_BYTES - 1).collect::<String>(),
-        ));
+        let nodel = Node::Leaf(NodeText::from_str(&"\r".repeat(MAX_BYTES)));
+        let noder = Node::Leaf(NodeText::from_str(&"\r".repeat(MAX_BYTES - 1)));
         let mut children = NodeChildren::new();
         children.push((nodel.text_info(), Arc::new(nodel)));
         children.push((noder.text_info(), Arc::new(noder)));

tests/clone_rope.rs

@@ -28,13 +28,13 @@ fn clone_rope() {
     let matches = Iterator::zip(rope1.chars(), rope2.chars())
         .map(|(a, b)| a == b)
         .all(|n| n);
-    assert_eq!(matches, true);
+    assert!(matches);
 
     // Insert something into the clone, and make sure they don't match
     // afterwards.
     rope2.insert(3891, "I'm doing fine, thanks!");
     let matches = Iterator::zip(rope1.chars(), rope2.chars())
         .map(|(a, b)| a == b)
         .all(|n| n);
-    assert_eq!(matches, false);
+    assert!(!matches);
 }

tests/clone_rope_to_thread.rs

@@ -51,7 +51,7 @@ fn clone_rope_to_thread() {
     let matches = Iterator::zip(rope1.chars(), rope2.chars())
         .map(|(a, b)| a == b)
         .all(|n| n);
-    assert_eq!(matches, true);
+    assert!(matches);
 
     // Send rope2 to the other thread again for more modifications.
     tx1.send(rope2).unwrap();
@@ -61,5 +61,5 @@ fn clone_rope_to_thread() {
     let matches = Iterator::zip(rope1.chars(), rope2.chars())
         .map(|(a, b)| a == b)
         .all(|n| n);
-    assert_eq!(matches, false);
+    assert!(!matches);
 }