Introduce code module

mlafeldt · mlafeldt · commit 0ecd25006d4e · 2020-05-26T18:06:25.000+02:00
diff --git a/src/cb1.rs b/src/cb1.rs
@@ -97,7 +97,7 @@ const SEEDS: [[u32; 16]; 3] = [
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{format_code, parse_code};
+    use crate::code;
 
     struct Test {
         decrypted: &'static str,
@@ -136,36 +136,36 @@ mod tests {
     #[test]
     fn test_encrypt_code() {
         for t in tests().iter() {
-            let code = parse_code(t.decrypted);
+            let code = code::parse(t.decrypted);
             let result = encrypt_code(code.0, code.1);
-            assert_eq!(t.encrypted, format_code(result));
+            assert_eq!(t.encrypted, code::format(result));
         }
     }
 
     #[test]
     fn test_encrypt_code_mut() {
         for t in tests().iter() {
-            let mut code = parse_code(t.decrypted);
+            let mut code = code::parse(t.decrypted);
             encrypt_code_mut(&mut code.0, &mut code.1);
-            assert_eq!(t.encrypted, format_code(code));
+            assert_eq!(t.encrypted, code::format(code));
         }
     }
 
     #[test]
     fn test_decrypt_code() {
         for t in tests().iter() {
-            let code = parse_code(t.encrypted);
+            let code = code::parse(t.encrypted);
             let result = decrypt_code(code.0, code.1);
-            assert_eq!(t.decrypted, format_code(result));
+            assert_eq!(t.decrypted, code::format(result));
         }
     }
 
     #[test]
     fn test_decrypt_code_mut() {
         for t in tests().iter() {
-            let mut code = parse_code(t.encrypted);
+            let mut code = code::parse(t.encrypted);
             decrypt_code_mut(&mut code.0, &mut code.1);
-            assert_eq!(t.decrypted, format_code(code));
+            assert_eq!(t.decrypted, code::format(code));
         }
     }
 }
diff --git a/src/cb7.rs b/src/cb7.rs
@@ -477,7 +477,7 @@ const SEEDS: [[u8; 256]; 5] = [
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{format_code, parse_code};
+    use crate::code;
 
     fn mul_tests() -> Vec<(u32, u32, u32)> {
         vec![
@@ -616,14 +616,14 @@ mod tests {
     #[test]
     fn test_encrypt_code() {
         for t in tests().iter() {
-            let code = parse_code(t.beefcode);
+            let code = code::parse(t.beefcode);
             let mut cb7 = Cb7::new();
             cb7.beefcode(code.0, code.1);
 
             for (i, line) in t.decrypted.iter().enumerate() {
-                let code = parse_code(line);
+                let code = code::parse(line);
                 let result = cb7.encrypt_code(code.0, code.1);
-                assert_eq!(t.encrypted[i], format_code(result));
+                assert_eq!(t.encrypted[i], code::format(result));
 
                 if is_beefcode(code.0) {
                     cb7.beefcode(code.0, code.1)
@@ -635,15 +635,15 @@ mod tests {
     #[test]
     fn test_encrypt_code_mut() {
         for t in tests().iter() {
-            let code = parse_code(t.beefcode);
+            let code = code::parse(t.beefcode);
             let mut cb7 = Cb7::new();
             cb7.beefcode(code.0, code.1);
 
             for (i, line) in t.decrypted.iter().enumerate() {
-                let mut code = parse_code(line);
+                let mut code = code::parse(line);
                 let oldcode = code;
                 cb7.encrypt_code_mut(&mut code.0, &mut code.1);
-                assert_eq!(t.encrypted[i], format_code(code));
+                assert_eq!(t.encrypted[i], code::format(code));
 
                 if is_beefcode(oldcode.0) {
                     cb7.beefcode(oldcode.0, oldcode.1)
@@ -655,14 +655,14 @@ mod tests {
     #[test]
     fn test_decrypt_code() {
         for t in tests().iter() {
-            let code = parse_code(t.beefcode);
+            let code = code::parse(t.beefcode);
             let mut cb7 = Cb7::new();
             cb7.beefcode(code.0, code.1);
 
             for (i, line) in t.encrypted.iter().enumerate() {
-                let code = parse_code(line);
+                let code = code::parse(line);
                 let result = cb7.decrypt_code(code.0, code.1);
-                assert_eq!(t.decrypted[i], format_code(result));
+                assert_eq!(t.decrypted[i], code::format(result));
 
                 if is_beefcode(result.0) {
                     cb7.beefcode(result.0, result.1)
@@ -674,14 +674,14 @@ mod tests {
     #[test]
     fn test_decrypt_code_mut() {
         for t in tests().iter() {
-            let code = parse_code(t.beefcode);
+            let code = code::parse(t.beefcode);
             let mut cb7 = Cb7::new();
             cb7.beefcode(code.0, code.1);
 
             for (i, line) in t.encrypted.iter().enumerate() {
-                let mut code = parse_code(line);
+                let mut code = code::parse(line);
                 cb7.decrypt_code_mut(&mut code.0, &mut code.1);
-                assert_eq!(t.decrypted[i], format_code(code));
+                assert_eq!(t.decrypted[i], code::format(code));
 
                 if is_beefcode(code.0) {
                     cb7.beefcode(code.0, code.1)
diff --git a/src/lib.rs b/src/lib.rs
@@ -342,9 +342,9 @@ mod tests {
     fn test_encrypt_code() {
         for t in tests().iter_mut() {
             for (i, line) in t.decrypted.iter().enumerate() {
-                let code = parse_code(line);
+                let code = code::parse(line);
                 let result = t.cb.encrypt_code(code.0, code.1);
-                assert_eq!(t.encrypted[i], format_code(result));
+                assert_eq!(t.encrypted[i], code::format(result));
             }
         }
     }
@@ -353,9 +353,9 @@ mod tests {
     fn test_encrypt_code_mut() {
         for t in tests().iter_mut() {
             for (i, line) in t.decrypted.iter().enumerate() {
-                let mut code = parse_code(line);
+                let mut code = code::parse(line);
                 t.cb.encrypt_code_mut(&mut code.0, &mut code.1);
-                assert_eq!(t.encrypted[i], format_code(code));
+                assert_eq!(t.encrypted[i], code::format(code));
             }
         }
     }
@@ -364,9 +364,9 @@ mod tests {
     fn test_decrypt_code() {
         for t in tests().iter_mut() {
             for (i, line) in t.encrypted.iter().enumerate() {
-                let code = parse_code(line);
+                let code = code::parse(line);
                 let result = t.cb.decrypt_code(code.0, code.1);
-                assert_eq!(t.decrypted[i], format_code(result));
+                assert_eq!(t.decrypted[i], code::format(result));
             }
         }
     }
@@ -375,9 +375,9 @@ mod tests {
     fn test_decrypt_code_mut() {
         for t in tests().iter_mut() {
             for (i, line) in t.encrypted.iter().enumerate() {
-                let mut code = parse_code(line);
+                let mut code = code::parse(line);
                 t.cb.decrypt_code_mut(&mut code.0, &mut code.1);
-                assert_eq!(t.decrypted[i], format_code(code));
+                assert_eq!(t.decrypted[i], code::format(code));
             }
         }
     }
@@ -469,9 +469,9 @@ mod tests {
         for t in auto_tests().iter_mut() {
             let mut cb = Codebreaker::new();
             for (i, line) in t.input.iter().enumerate() {
-                let code = parse_code(line);
+                let code = code::parse(line);
                 let result = cb.auto_decrypt_code(code.0, code.1);
-                assert_eq!(t.output[i], format_code(result));
+                assert_eq!(t.output[i], code::format(result));
             }
         }
     }
@@ -481,21 +481,22 @@ mod tests {
         for t in auto_tests().iter_mut() {
             let mut cb = Codebreaker::new();
             for (i, line) in t.input.iter().enumerate() {
-                let mut code = parse_code(line);
+                let mut code = code::parse(line);
                 cb.auto_decrypt_code_mut(&mut code.0, &mut code.1);
-                assert_eq!(t.output[i], format_code(code));
+                assert_eq!(t.output[i], code::format(code));
             }
         }
     }
 }
 
 #[cfg(test)]
-fn parse_code(line: &str) -> (u32, u32) {
-    let code: Vec<u32> = line.split(' ').map(|v| u32::from_str_radix(v, 16).unwrap()).collect();
-    (code[0], code[1])
-}
+mod code {
+    pub(crate) fn parse(line: &str) -> (u32, u32) {
+        let code: Vec<u32> = line.split(' ').map(|v| u32::from_str_radix(v, 16).unwrap()).collect();
+        (code[0], code[1])
+    }
 
-#[cfg(test)]
-fn format_code(code: (u32, u32)) -> String {
-    format!("{:08X} {:08X}", code.0, code.1)
+    pub(crate) fn format(code: (u32, u32)) -> String {
+        format!("{:08X} {:08X}", code.0, code.1)
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ const SEEDS: [[u32; 16]; 3] = [`
`97`	`97`	`#[cfg(test)]`
`98`	`98`	`mod tests {`
`99`	`99`	`use super::*;`
`100`		`- use crate::{format_code, parse_code};`
	`100`	`+ use crate::code;`
`101`	`101`
`102`	`102`	`struct Test {`
`103`	`103`	`decrypted: &'static str,`
`@@ -136,36 +136,36 @@ mod tests {`
`136`	`136`	`#[test]`
`137`	`137`	`fn test_encrypt_code() {`
`138`	`138`	`for t in tests().iter() {`
`139`		`- let code = parse_code(t.decrypted);`
	`139`	`+ let code = code::parse(t.decrypted);`
`140`	`140`	`let result = encrypt_code(code.0, code.1);`
`141`		`- assert_eq!(t.encrypted, format_code(result));`
	`141`	`+ assert_eq!(t.encrypted, code::format(result));`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`#[test]`
`146`	`146`	`fn test_encrypt_code_mut() {`
`147`	`147`	`for t in tests().iter() {`
`148`		`- let mut code = parse_code(t.decrypted);`
	`148`	`+ let mut code = code::parse(t.decrypted);`
`149`	`149`	`encrypt_code_mut(&mut code.0, &mut code.1);`
`150`		`- assert_eq!(t.encrypted, format_code(code));`
	`150`	`+ assert_eq!(t.encrypted, code::format(code));`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`#[test]`
`155`	`155`	`fn test_decrypt_code() {`
`156`	`156`	`for t in tests().iter() {`
`157`		`- let code = parse_code(t.encrypted);`
	`157`	`+ let code = code::parse(t.encrypted);`
`158`	`158`	`let result = decrypt_code(code.0, code.1);`
`159`		`- assert_eq!(t.decrypted, format_code(result));`
	`159`	`+ assert_eq!(t.decrypted, code::format(result));`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`#[test]`
`164`	`164`	`fn test_decrypt_code_mut() {`
`165`	`165`	`for t in tests().iter() {`
`166`		`- let mut code = parse_code(t.encrypted);`
	`166`	`+ let mut code = code::parse(t.encrypted);`
`167`	`167`	`decrypt_code_mut(&mut code.0, &mut code.1);`
`168`		`- assert_eq!(t.decrypted, format_code(code));`
	`168`	`+ assert_eq!(t.decrypted, code::format(code));`
`169`	`169`	`}`
`170`	`170`	`}`
`171`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -342,9 +342,9 @@ mod tests {`
`342`	`342`	`fn test_encrypt_code() {`
`343`	`343`	`for t in tests().iter_mut() {`
`344`	`344`	`for (i, line) in t.decrypted.iter().enumerate() {`
`345`		`- let code = parse_code(line);`
	`345`	`+ let code = code::parse(line);`
`346`	`346`	`let result = t.cb.encrypt_code(code.0, code.1);`
`347`		`- assert_eq!(t.encrypted[i], format_code(result));`
	`347`	`+ assert_eq!(t.encrypted[i], code::format(result));`
`348`	`348`	`}`
`349`	`349`	`}`
`350`	`350`	`}`
`@@ -353,9 +353,9 @@ mod tests {`
`353`	`353`	`fn test_encrypt_code_mut() {`
`354`	`354`	`for t in tests().iter_mut() {`
`355`	`355`	`for (i, line) in t.decrypted.iter().enumerate() {`
`356`		`- let mut code = parse_code(line);`
	`356`	`+ let mut code = code::parse(line);`
`357`	`357`	`t.cb.encrypt_code_mut(&mut code.0, &mut code.1);`
`358`		`- assert_eq!(t.encrypted[i], format_code(code));`
	`358`	`+ assert_eq!(t.encrypted[i], code::format(code));`
`359`	`359`	`}`
`360`	`360`	`}`
`361`	`361`	`}`
`@@ -364,9 +364,9 @@ mod tests {`
`364`	`364`	`fn test_decrypt_code() {`
`365`	`365`	`for t in tests().iter_mut() {`
`366`	`366`	`for (i, line) in t.encrypted.iter().enumerate() {`
`367`		`- let code = parse_code(line);`
	`367`	`+ let code = code::parse(line);`
`368`	`368`	`let result = t.cb.decrypt_code(code.0, code.1);`
`369`		`- assert_eq!(t.decrypted[i], format_code(result));`
	`369`	`+ assert_eq!(t.decrypted[i], code::format(result));`
`370`	`370`	`}`
`371`	`371`	`}`
`372`	`372`	`}`
`@@ -375,9 +375,9 @@ mod tests {`
`375`	`375`	`fn test_decrypt_code_mut() {`
`376`	`376`	`for t in tests().iter_mut() {`
`377`	`377`	`for (i, line) in t.encrypted.iter().enumerate() {`
`378`		`- let mut code = parse_code(line);`
	`378`	`+ let mut code = code::parse(line);`
`379`	`379`	`t.cb.decrypt_code_mut(&mut code.0, &mut code.1);`
`380`		`- assert_eq!(t.decrypted[i], format_code(code));`
	`380`	`+ assert_eq!(t.decrypted[i], code::format(code));`
`381`	`381`	`}`
`382`	`382`	`}`
`383`	`383`	`}`
`@@ -469,9 +469,9 @@ mod tests {`
`469`	`469`	`for t in auto_tests().iter_mut() {`
`470`	`470`	`let mut cb = Codebreaker::new();`
`471`	`471`	`for (i, line) in t.input.iter().enumerate() {`
`472`		`- let code = parse_code(line);`
	`472`	`+ let code = code::parse(line);`
`473`	`473`	`let result = cb.auto_decrypt_code(code.0, code.1);`
`474`		`- assert_eq!(t.output[i], format_code(result));`
	`474`	`+ assert_eq!(t.output[i], code::format(result));`
`475`	`475`	`}`
`476`	`476`	`}`
`477`	`477`	`}`
`@@ -481,21 +481,22 @@ mod tests {`
`481`	`481`	`for t in auto_tests().iter_mut() {`
`482`	`482`	`let mut cb = Codebreaker::new();`
`483`	`483`	`for (i, line) in t.input.iter().enumerate() {`
`484`		`- let mut code = parse_code(line);`
	`484`	`+ let mut code = code::parse(line);`
`485`	`485`	`cb.auto_decrypt_code_mut(&mut code.0, &mut code.1);`
`486`		`- assert_eq!(t.output[i], format_code(code));`
	`486`	`+ assert_eq!(t.output[i], code::format(code));`
`487`	`487`	`}`
`488`	`488`	`}`
`489`	`489`	`}`
`490`	`490`	`}`
`491`	`491`
`492`	`492`	`#[cfg(test)]`
`493`		`-fn parse_code(line: &str) -> (u32, u32) {`
`494`		`- let code: Vec<u32> = line.split(' ').map(\|v\| u32::from_str_radix(v, 16).unwrap()).collect();`
`495`		`- (code[0], code[1])`
`496`		`-}`
	`493`	`+mod code {`
	`494`	`+ pub(crate) fn parse(line: &str) -> (u32, u32) {`
	`495`	`+ let code: Vec<u32> = line.split(' ').map(\|v\| u32::from_str_radix(v, 16).unwrap()).collect();`
	`496`	`+ (code[0], code[1])`
	`497`	`+ }`
`497`	`498`
`498`		`-#[cfg(test)]`
`499`		`-fn format_code(code: (u32, u32)) -> String {`
`500`		`- format!("{:08X} {:08X}", code.0, code.1)`
	`499`	`+ pub(crate) fn format(code: (u32, u32)) -> String {`
	`500`	`+ format!("{:08X} {:08X}", code.0, code.1)`
	`501`	`+ }`
`501`	`502`	`}`