Clippy and fix doc-tests

Signed-off-by: FedericoBruzzone <[email protected]>
FedericoBruzzone · Apr 14, 2024 · 41639e3 · 41639e3
1 parent 6f77171
commit 41639e3
Show file tree

Hide file tree

Showing 10 changed files with 39 additions and 47 deletions.
diff --git a/src/bin/main.rs b/src/bin/main.rs
@@ -38,44 +38,44 @@ fn main() {
     println!("UTF8 ------------------------------------");
 
     let v = vec![0x0024];
-    let utf8_vec = utf8::encode_in_utf8(&v);
-    let unicode_vec_from_utf8 = utf8::decode_from_utf8(&utf8_vec);
+    let utf8_vec = utf8::encode_in_utf8(v);
+    let _unicode_vec_from_utf8 = utf8::decode_from_utf8(&utf8_vec);
     utf8::print_utf8_b(&utf8_vec);
 
     let v = vec![0x0418];
-    let utf8_vec = utf8::encode_in_utf8(&v);
-    let unicode_vec_from_utf8 = utf8::decode_from_utf8(&utf8_vec);
+    let utf8_vec = utf8::encode_in_utf8(v);
+    let _unicode_vec_from_utf8 = utf8::decode_from_utf8(&utf8_vec);
     utf8::print_utf8_b(&utf8_vec);
 
     let v = vec![0x20AC];
-    let utf8_vec = utf8::encode_in_utf8(&v);
-    let unicode_vec_from_utf8 = utf8::decode_from_utf8(&utf8_vec);
+    let utf8_vec = utf8::encode_in_utf8(v);
+    let _unicode_vec_from_utf8 = utf8::decode_from_utf8(&utf8_vec);
     utf8::print_utf8_b(&utf8_vec);
 
     let v = vec![0x10348];
-    let utf8_vec = utf8::encode_in_utf8(&v);
-    let unicode_vec_from_utf8 = utf8::decode_from_utf8(&utf8_vec);
+    let utf8_vec = utf8::encode_in_utf8(v.clone());
+    let _unicode_vec_from_utf8 = utf8::decode_from_utf8(&utf8_vec);
     utf8::print_utf8_b(&utf8_vec);
-    unicode::print_unicode_b(&v);
+    unicode::print_unicode_b(v);
 
     println!("UTF16 ------------------------------------");
     let v = vec![0x10001];
     // let v = vec![0xD800, 0xDC00];
-    let utf16_vec = utf16::encode_in_utf16(&v);
+    let utf16_vec = utf16::encode_in_utf16(v);
     // println!("utf16_vec: {:x?}", utf16_vec);
-    let unicode_vec_from_utf16 = utf16::decode_from_utf16(&utf16_vec);
+    let unicode_vec_from_utf16 = utf16::decode_from_utf16(utf16_vec.clone());
     // println!("unicode_vec_from_utf16: {:x?}", unicode_vec_from_utf16);
-    utf16::print_utf16_b(&utf16_vec);
+    utf16::print_utf16_b(utf16_vec);
 
-    unicode::print_unicode_b(&unicode_vec_from_utf16);
+    unicode::print_unicode_b(unicode_vec_from_utf16);
 
     println!("UCS2 ------------------------------------");
     let v2 = vec![0xFFEE];
     // let v = vec![0xD800, 0xDC00];
-    let ucs2_vec = ucs2::encode_in_ucs2(&v2);
-    let unicode_vec_from_utf16 = ucs2::decode_from_ucs2(&ucs2_vec);
-    utf16::print_utf16_b(&ucs2_vec);
-    unicode::print_unicode_b(&unicode_vec_from_utf16);
+    let ucs2_vec = ucs2::encode_in_ucs2(v2);
+    let unicode_vec_from_utf16 = ucs2::decode_from_ucs2(ucs2_vec.clone());
+    utf16::print_utf16_b(ucs2_vec);
+    unicode::print_unicode_b(unicode_vec_from_utf16);
 
     // let v2: Vec<u32> = vec![0x10001, 0x10002]; // Array of code point in unicode
     // let enc2 = utf8::encode_in_utf8(&v2);

diff --git a/src/ucs2/ucs2.rs → src/ucs2.rs b/src/ucs2/ucs2.rs → src/ucs2.rs
@@ -69,7 +69,7 @@ fn print_ucs2_vec<T: AsRef<Vec<u16>>>(ucs2_cp: T, binary_flag: bool) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u16> = vec![0xFFEE];
-/// ucs2::print_ucs2(&v);
+/// print_ucs2(&v);
 /// ```
 /// **Output**
 /// ```text
@@ -93,7 +93,7 @@ pub fn print_ucs2<T: AsRef<Vec<u16>>>(utf2_cp: T) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u16> = vec![0xFFEE];
-/// ucs2::print_ucs2_b(&v);
+/// print_ucs2_b(&v);
 /// ```
 /// **Output**
 /// ```text
@@ -120,7 +120,7 @@ pub fn print_ucs2_b<T: AsRef<Vec<u16>>>(ucs2_cp: T) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u32> = vec![0xFFEE]; // Array of code points in unicode
-/// let enc: Vec<u16> = ucs2::encode_in_ucs2(&v);
+/// let enc: Vec<u16> = encode_in_ucs2(&v);
 /// assert_eq!(enc, vec![0xFFEE]);
 /// ```
 pub fn encode_in_ucs2<T: AsRef<Vec<u32>>>(unicode_cp: T) -> Vec<u16> {
@@ -151,7 +151,7 @@ pub fn encode_in_ucs2<T: AsRef<Vec<u32>>>(unicode_cp: T) -> Vec<u16> {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u16> = vec![0xFFEE]; // Array of code points in UCS-2
-/// let dec: Vec<u32> = ucs2::decode_from_ucs2(&v);
+/// let dec: Vec<u32> = decode_from_ucs2(&v);
 /// assert_eq!(dec, vec![0xFFEE]);
 /// ```
 pub fn decode_from_ucs2<T: AsRef<Vec<u16>>>(ucs2_cp: T) -> Vec<u32> {

diff --git a/src/ucs2/mod.rs b/src/ucs2/mod.rs
diff --git a/src/unicode/unicode.rs → src/unicode.rs b/src/unicode/unicode.rs → src/unicode.rs
@@ -72,7 +72,7 @@ pub fn check_code_point(code_point: u32) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u32> = vec![0x10001];
-/// unicode::print_unicode_b(&v);
+/// print_unicode_b(&v);
 /// ```
 /// **Output**
 /// ```text
@@ -98,7 +98,7 @@ pub fn print_unicode_b<T: AsRef<Vec<u32>>>(unicode_cp: T) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u32> = vec![0x10001];
-/// unicode::print_unicode(&v);
+/// print_unicode(&v);
 /// ```
 /// **Output**
 /// ```text

diff --git a/src/unicode/mod.rs b/src/unicode/mod.rs
diff --git a/src/utf16/utf16.rs → src/utf16.rs b/src/utf16/utf16.rs → src/utf16.rs
@@ -190,7 +190,7 @@ fn print_utf16_vec<T: AsRef<Vec<u16>>>(utf16_cp: T, binary_flag: bool) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u16> = vec![0xD800, 0xDC00];
-/// utf16::print_utf16(&v);
+/// print_utf16(&v);
 /// ```
 /// **Output**
 /// ```text
@@ -214,7 +214,7 @@ pub fn print_utf16<T: AsRef<Vec<u16>>>(utf16_cp: T) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u16> = vec![0xD800, 0xDC00];
-/// utf16::print_utf16(&v);
+/// print_utf16(&v);
 /// ```
 /// **Output**
 /// ```text
@@ -242,7 +242,7 @@ pub fn print_utf16_b<T: AsRef<Vec<u16>>>(utf16_cp: T) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u32> = vec![0x10001]; // Array of code points in unicode
-/// let enc: Vec<u16> = utf16::encode_in_utf16(&v);
+/// let enc: Vec<u16> = encode_in_utf16(&v);
 /// assert_eq!(enc, vec![0xD800, 0xDC01]);
 /// ```
 pub fn encode_in_utf16<T: AsRef<Vec<u32>>>(unicode_cp: T) -> Vec<u16> {
@@ -271,7 +271,7 @@ pub fn encode_in_utf16<T: AsRef<Vec<u32>>>(unicode_cp: T) -> Vec<u16> {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u16> = vec![0xD800, 0xDC01]; // Array of code points in UTF-16
-/// let dec: Vec<u32> = utf16::decode_from_utf16(&v);
+/// let dec: Vec<u32> = decode_from_utf16(&v);
 /// assert_eq!(dec, vec![0x10001]);
 /// ```
 pub fn decode_from_utf16<T: AsRef<Vec<u16>>>(utf16_cp: T) -> Vec<u32> {

diff --git a/src/utf16/mod.rs b/src/utf16/mod.rs
diff --git a/src/utf8/utf8.rs → src/utf8.rs b/src/utf8/utf8.rs → src/utf8.rs
@@ -353,7 +353,7 @@ fn print_utf8_vec<T: AsRef<Vec<u8>>>(utf8_cp: T, binary_flag: bool) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u8> = vec![0xf0, 0x90, 0x80, 0x81];
-/// utf8::print_utf8(&v);
+/// print_utf8(&v);
 /// ```
 /// **Output**
 /// ```text
@@ -377,7 +377,7 @@ pub fn print_utf8<T: AsRef<Vec<u8>>>(uft8_cp: T) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u8> = vec![0xf0, 0x90, 0x80, 0x81];
-/// utf8::print_utf8_b(&v);
+/// print_utf8_b(&v);
 /// ```
 /// **Output**
 /// ```text
@@ -405,7 +405,7 @@ pub fn print_utf8_b<T: AsRef<Vec<u8>>>(uft8_cp: T) {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u32> = vec![0x10001]; // Array of code points in unicode
-/// let enc: Vec<u8> = utf8::encode_in_utf8(&v);
+/// let enc: Vec<u8> = encode_in_utf8(&v);
 /// assert_eq!(enc, vec![0xf0, 0x90, 0x80, 0x81]);
 /// ```
 pub fn encode_in_utf8<T: AsRef<Vec<u32>>>(unicode_cp: T) -> Vec<u8> {
@@ -434,7 +434,7 @@ pub fn encode_in_utf8<T: AsRef<Vec<u32>>>(unicode_cp: T) -> Vec<u8> {
 /// ```rust
 /// use encdec::prelude::*;
 /// let v: Vec<u8> = vec![0xf0, 0x90, 0x80, 0x81]; // Array of code points in UTF-8
-/// let dec: Vec<u32> = utf8::decode_from_utf8(&v);
+/// let dec: Vec<u32> = decode_from_utf8(&v);
 /// assert_eq!(dec, vec![0x10001]);
 /// ```
 pub fn decode_from_utf8<T: AsRef<Vec<u8>>>(utf8_cp: T) -> Vec<u32> {

diff --git a/src/utf8/mod.rs b/src/utf8/mod.rs
diff --git a/tests/test_utf8.rs b/tests/test_utf8.rs
@@ -3,35 +3,35 @@ use encdec::prelude::*;
 #[test]
 fn test_utf8_encode_in_utf8_1() {
     let v: Vec<u32> = vec![0x10001];
-    let enc: Vec<u8> = utf8::encode_in_utf8(&v);
+    let enc: Vec<u8> = encode_in_utf8(v);
     assert_eq!(enc, vec![0xf0, 0x90, 0x80, 0x81]);
 }
 
 #[test]
 fn test_utf8_decode_from_utf8_1() {
     let enc: Vec<u8> = vec![0xf0, 0x90, 0x80, 0x81];
-    let v: Vec<u32> = utf8::decode_from_utf8(&enc);
+    let v: Vec<u32> = decode_from_utf8(enc);
     assert_eq!(v, vec![0x10001]);
 }
 
 #[test]
 fn test_utf8_encode_in_utf8_2() {
     let v: Vec<u32> = vec![0x10001, 0x10001];
-    let enc: Vec<u8> = utf8::encode_in_utf8(&v);
+    let enc: Vec<u8> = encode_in_utf8(v);
     assert_eq!(enc, vec![0xf0, 0x90, 0x80, 0x81, 0xf0, 0x90, 0x80, 0x81]);
 }
 
 #[test]
 fn test_utf8_decode_from_utf8_2() {
     let enc: Vec<u8> = vec![0xf0, 0x90, 0x80, 0x81, 0xf0, 0x90, 0x80, 0x81];
-    let v: Vec<u32> = utf8::decode_from_utf8(&enc);
+    let v: Vec<u32> = decode_from_utf8(enc);
     assert_eq!(v, vec![0x10001, 0x10001]);
 }
 
 #[test]
 fn test_utf8_encode_in_utf8_3() {
     let v: Vec<u32> = vec![0x10001, 0x10001, 0x10001];
-    let enc: Vec<u8> = utf8::encode_in_utf8(&v);
+    let enc: Vec<u8> = encode_in_utf8(v);
     assert_eq!(
         enc,
         vec![0xf0, 0x90, 0x80, 0x81, 0xf0, 0x90, 0x80, 0x81, 0xf0, 0x90, 0x80, 0x81]
@@ -43,20 +43,20 @@ fn test_utf8_decode_from_utf8_3() {
     let enc: Vec<u8> = vec![
         0xf0, 0x90, 0x80, 0x81, 0xf0, 0x90, 0x80, 0x81, 0xf0, 0x90, 0x80, 0x81,
     ];
-    let v: Vec<u32> = utf8::decode_from_utf8(&enc);
+    let v: Vec<u32> = decode_from_utf8(enc);
     assert_eq!(v, vec![0x10001, 0x10001, 0x10001]);
 }
 
 #[test]
 fn test_utf8_encode_in_utf8_4() {
     let v: Vec<u32> = vec![0x10001, 0x23456];
-    let enc: Vec<u8> = utf8::encode_in_utf8(&v);
+    let enc: Vec<u8> = encode_in_utf8(v);
     assert_eq!(enc, vec![0xf0, 0x90, 0x80, 0x81, 0xf0, 0xa3, 0x91, 0x96]);
 }
 
 #[test]
 fn test_utf8_decode_from_utf8_4() {
     let enc: Vec<u8> = vec![0xf0, 0x90, 0x80, 0x81, 0xf0, 0xa3, 0x91, 0x96];
-    let v: Vec<u32> = utf8::decode_from_utf8(&enc);
+    let v: Vec<u32> = decode_from_utf8(enc);
     assert_eq!(v, vec![0x10001, 0x23456]);
 }