simplify encoding test macro (#4385)

helix-view/src/document.rs

@@ -1354,84 +1354,66 @@ mod test {
         );
     }
 
-    macro_rules! test_decode {
+    macro_rules! decode {
-        ($label:expr, $label_override:expr) => {
-            let encoding = encoding::Encoding::for_label($label_override.as_bytes()).unwrap();
-            let base_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/encoding");
-            let path = base_path.join(format!("{}_in.txt", $label));
-            let ref_path = base_path.join(format!("{}_in_ref.txt", $label));
-            assert!(path.exists());
-            assert!(ref_path.exists());
-
-            let mut file = std::fs::File::open(path).unwrap();
-            let text = from_reader(&mut file, Some(encoding))
-                .unwrap()
-                .0
-                .to_string();
-            let expectation = std::fs::read_to_string(ref_path).unwrap();
-            assert_eq!(text[..], expectation[..]);
-        };
-    }
-
-    macro_rules! test_encode {
-        ($label:expr, $label_override:expr) => {
-            let encoding = encoding::Encoding::for_label($label_override.as_bytes()).unwrap();
-            let base_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/encoding");
-            let path = base_path.join(format!("{}_out.txt", $label));
-            let ref_path = base_path.join(format!("{}_out_ref.txt", $label));
-            assert!(path.exists());
-            assert!(ref_path.exists());
-
-            let text = Rope::from_str(&std::fs::read_to_string(path).unwrap());
-            let mut buf: Vec<u8> = Vec::new();
-            helix_lsp::block_on(to_writer(&mut buf, encoding, &text)).unwrap();
-
-            let expectation = std::fs::read(ref_path).unwrap();
-            assert_eq!(buf, expectation);
-        };
-    }
-
-    macro_rules! test_decode_fn {
         ($name:ident, $label:expr, $label_override:expr) => {
             #[test]
             fn $name() {
-                test_decode!($label, $label_override);
+                let encoding = encoding::Encoding::for_label($label_override.as_bytes()).unwrap();
-            }
+                let base_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/encoding");
+                let path = base_path.join(format!("{}_in.txt", $label));
+                let ref_path = base_path.join(format!("{}_in_ref.txt", $label));
+                assert!(path.exists());
+                assert!(ref_path.exists());
+
+                let mut file = std::fs::File::open(path).unwrap();
+                let text = from_reader(&mut file, Some(encoding))
+                    .unwrap()
+                    .0
+                    .to_string();
+                let expectation = std::fs::read_to_string(ref_path).unwrap();
+                assert_eq!(text[..], expectation[..]);
+            }  
         };
         ($name:ident, $label:expr) => {
-            #[test]
+            decode!($name, $label, $label);
-            fn $name() {
-                test_decode!($label, $label);
-            }
         };
     }
 
-    macro_rules! test_encode_fn {
+    macro_rules! encode {
         ($name:ident, $label:expr, $label_override:expr) => {
             #[test]
             fn $name() {
-                test_encode!($label, $label_override);
+                let encoding = encoding::Encoding::for_label($label_override.as_bytes()).unwrap();
+                let base_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/encoding");
+                let path = base_path.join(format!("{}_out.txt", $label));
+                let ref_path = base_path.join(format!("{}_out_ref.txt", $label));
+                assert!(path.exists());
+                assert!(ref_path.exists());
+    
+                let text = Rope::from_str(&std::fs::read_to_string(path).unwrap());
+                let mut buf: Vec<u8> = Vec::new();
+                helix_lsp::block_on(to_writer(&mut buf, encoding, &text)).unwrap();
+    
+                let expectation = std::fs::read(ref_path).unwrap();
+                assert_eq!(buf, expectation);
             }
         };
         ($name:ident, $label:expr) => {
-            #[test]
+            encode!($name, $label, $label);
-            fn $name() {
-                test_encode!($label, $label);
-            }
         };
     }
 
-    test_decode_fn!(test_big5_decode, "big5");
+    decode!(big5_decode, "big5");
-    test_encode_fn!(test_big5_encode, "big5");
+    encode!(big5_encode, "big5");
-    test_decode_fn!(test_euc_kr_decode, "euc_kr", "EUC-KR");
+    decode!(euc_kr_decode, "euc_kr", "EUC-KR");
-    test_encode_fn!(test_euc_kr_encode, "euc_kr", "EUC-KR");
+    encode!(euc_kr_encode, "euc_kr", "EUC-KR");
-    test_decode_fn!(test_gb18030_decode, "gb18030");
+    decode!(gb18030_decode, "gb18030");
-    test_encode_fn!(test_gb18030_encode, "gb18030");
+    encode!(gb18030_encode, "gb18030");
-    test_decode_fn!(test_iso_2022_jp_decode, "iso_2022_jp", "ISO-2022-JP");
+    decode!(iso_2022_jp_decode, "iso_2022_jp", "ISO-2022-JP");
-    test_encode_fn!(test_iso_2022_jp_encode, "iso_2022_jp", "ISO-2022-JP");
+    encode!(iso_2022_jp_encode, "iso_2022_jp", "ISO-2022-JP");
-    test_decode_fn!(test_jis0208_decode, "jis0208", "EUC-JP");
+    decode!(jis0208_decode, "jis0208", "EUC-JP");
-    test_encode_fn!(test_jis0208_encode, "jis0208", "EUC-JP");
+    encode!(jis0208_encode, "jis0208", "EUC-JP");
-    test_decode_fn!(test_jis0212_decode, "jis0212", "EUC-JP");
+    decode!(jis0212_decode, "jis0212", "EUC-JP");
-    test_decode_fn!(test_shift_jis_decode, "shift_jis");
+    decode!(shift_jis_decode, "shift_jis");
-    test_encode_fn!(test_shift_jis_encode, "shift_jis");
+    encode!(shift_jis_encode, "shift_jis");
 }