rustfmt (RustCrypto#54)

Author: tarcieri

block-cipher-trait/src/dev.rs

@@ -1,13 +1,12 @@
-
 #[macro_export]
 macro_rules! new_test {
     ($name:ident, $test_name:expr, $cipher:ty) => {
         #[test]
         fn $name() {
-            use block_cipher_trait::BlockCipher;
-            use block_cipher_trait::generic_array::GenericArray;
-            use block_cipher_trait::generic_array::typenum::Unsigned;
             use block_cipher_trait::blobby::Blob3Iterator;
+            use block_cipher_trait::generic_array::typenum::Unsigned;
+            use block_cipher_trait::generic_array::GenericArray;
+            use block_cipher_trait::BlockCipher;
 
             fn run_test(key: &[u8], pt: &[u8], ct: &[u8]) -> bool {
                 let state = <$cipher as BlockCipher>::new_varkey(key).unwrap();
@@ -45,14 +44,22 @@ macro_rules! new_test {
                 // check that `encrypt_blocks` and `encrypt_block`
                 // result in the same ciphertext
                 state.encrypt_blocks(&mut blocks1);
-                for b in blocks2.iter_mut() { state.encrypt_block(b); }
-                if blocks1 != blocks2 { return false; }
+                for b in blocks2.iter_mut() {
+                    state.encrypt_block(b);
+                }
+                if blocks1 != blocks2 {
+                    return false;
+                }
 
                 // check that `encrypt_blocks` and `encrypt_block`
                 // result in the same plaintext
                 state.decrypt_blocks(&mut blocks1);
-                for b in blocks2.iter_mut() { state.decrypt_block(b); }
-                if blocks1 != blocks2 { return false; }
+                for b in blocks2.iter_mut() {
+                    state.decrypt_block(b);
+                }
+                if blocks1 != blocks2 {
+                    return false;
+                }
 
                 true
             }
@@ -64,23 +71,25 @@ macro_rules! new_test {
                 let plaintext = row[1];
                 let ciphertext = row[2];
                 if !run_test(key, plaintext, ciphertext) {
-                    panic!("\n\
-                        Failed test №{}\n\
-                        key:\t{:?}\n\
-                        plaintext:\t{:?}\n\
-                        ciphertext:\t{:?}\n",
+                    panic!(
+                        "\n\
+                         Failed test №{}\n\
+                         key:\t{:?}\n\
+                         plaintext:\t{:?}\n\
+                         ciphertext:\t{:?}\n",
                         i, key, plaintext, ciphertext,
                     );
                 }
 
                 // test parallel blocks encryption/decryption
                 if pb != 1 {
                     if !run_par_test(key, plaintext) {
-                        panic!("\n\
-                            Failed parallel test №{}\n\
-                            key:\t{:?}\n\
-                            plaintext:\t{:?}\n\
-                            ciphertext:\t{:?}\n",
+                        panic!(
+                            "\n\
+                             Failed parallel test №{}\n\
+                             key:\t{:?}\n\
+                             plaintext:\t{:?}\n\
+                             ciphertext:\t{:?}\n",
                             i, key, plaintext, ciphertext,
                         );
                     }
@@ -90,16 +99,16 @@ macro_rules! new_test {
             let key = Default::default();
             let _ = <$cipher as BlockCipher>::new(&key).clone();
         }
-    }
+    };
 }
 
 #[macro_export]
 macro_rules! bench {
     ($cipher:path, $key_len:expr) => {
         extern crate test;
 
-        use test::Bencher;
         use block_cipher_trait::BlockCipher;
+        use test::Bencher;
 
         #[bench]
         pub fn encrypt(bh: &mut Bencher) {
@@ -124,5 +133,5 @@ macro_rules! bench {
             });
             bh.bytes = block.len() as u64;
         }
-    }
+    };
 }

block-cipher-trait/src/lib.rs

@@ -1,20 +1,19 @@
 //! This crate defines a set of simple traits used to define functionality of
 //! block ciphers.
 #![no_std]
-#![doc(html_logo_url =
-    "https://raw.githubusercontent.com/RustCrypto/meta/master/logo_small.png")]
-pub extern crate generic_array;
+#![doc(html_logo_url = "https://raw.githubusercontent.com/RustCrypto/meta/master/logo_small.png")]
 #[cfg(feature = "dev")]
 pub extern crate blobby;
+pub extern crate generic_array;
 #[cfg(feature = "std")]
 extern crate std;
 
-use generic_array::{GenericArray, ArrayLength};
 use generic_array::typenum::Unsigned;
+use generic_array::{ArrayLength, GenericArray};
 
-mod errors;
 #[cfg(feature = "dev")]
 pub mod dev;
+mod errors;
 
 pub use errors::InvalidKeyLength;
 
@@ -57,20 +56,20 @@ pub trait BlockCipher: core::marker::Sized {
     ///
     /// If `ParBlocks` equals to 1 it's equivalent to `encrypt_block`.
     #[inline]
-    fn encrypt_blocks(&self,
-        blocks: &mut ParBlocks<Self::BlockSize, Self::ParBlocks>)
-    {
-        for block in blocks.iter_mut() { self.encrypt_block(block); }
+    fn encrypt_blocks(&self, blocks: &mut ParBlocks<Self::BlockSize, Self::ParBlocks>) {
+        for block in blocks.iter_mut() {
+            self.encrypt_block(block);
+        }
     }
 
     /// Decrypt several blocks in parallel using instruction level parallelism
     /// if possible.
     ///
     /// If `ParBlocks` equals to 1 it's equivalent to `decrypt_block`.
     #[inline]
-    fn decrypt_blocks(&self,
-        blocks: &mut ParBlocks<Self::BlockSize, Self::ParBlocks>)
-    {
-        for block in blocks.iter_mut() { self.decrypt_block(block); }
+    fn decrypt_blocks(&self, blocks: &mut ParBlocks<Self::BlockSize, Self::ParBlocks>) {
+        for block in blocks.iter_mut() {
+            self.decrypt_block(block);
+        }
     }
 }

crypto-mac/src/dev.rs

@@ -1,15 +1,12 @@
-
 #[macro_export]
 macro_rules! new_test {
     ($name:ident, $test_name:expr, $mac:ty) => {
         #[test]
         fn $name() {
-            use crypto_mac::Mac;
             use crypto_mac::blobby::Blob3Iterator;
+            use crypto_mac::Mac;
 
-            fn run_test(key: &[u8], input: &[u8], tag: &[u8])
-                -> Option<&'static str>
-            {
+            fn run_test(key: &[u8], input: &[u8], tag: &[u8]) -> Option<&'static str> {
                 let mut mac = <$mac as Mac>::new_varkey(key).unwrap();
                 mac.input(input);
                 let result = mac.result_reset();
@@ -40,17 +37,18 @@ macro_rules! new_test {
                 let input = row[1];
                 let tag = row[2];
                 if let Some(desc) = run_test(key, input, tag) {
-                    panic!("\n\
-                        Failed test №{}: {}\n\
-                        key:\t{:?}\n\
-                        input:\t{:?}\n\
-                        tag:\t{:?}\n",
+                    panic!(
+                        "\n\
+                         Failed test №{}: {}\n\
+                         key:\t{:?}\n\
+                         input:\t{:?}\n\
+                         tag:\t{:?}\n",
                         i, desc, key, input, tag,
                     );
                 }
             }
         }
-    }
+    };
 }
 
 #[macro_export]
@@ -73,12 +71,12 @@ macro_rules! bench {
     ($engine:path) => {
         extern crate test;
 
-        use test::Bencher;
         use crypto_mac::Mac;
+        use test::Bencher;
 
-        bench!(bench1_10,    $engine, 10);
-        bench!(bench2_100,   $engine, 100);
-        bench!(bench3_1000,  $engine, 1000);
+        bench!(bench1_10, $engine, 10);
+        bench!(bench2_100, $engine, 100);
+        bench!(bench3_1000, $engine, 1000);
         bench!(bench3_10000, $engine, 10000);
-    }
+    };
 }

crypto-mac/src/errors.rs

@@ -10,7 +10,6 @@ pub struct MacError;
 #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
 pub struct InvalidKeyLength;
 
-
 impl fmt::Display for MacError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str("failed MAC verification")
@@ -35,4 +34,4 @@ impl error::Error for InvalidKeyLength {
     fn description(&self) -> &str {
         "invalid key length"
     }
-}
+}

crypto-mac/src/lib.rs

@@ -1,22 +1,21 @@
 //! This crate provides trait for Message Authentication Code (MAC) algorithms.
 #![no_std]
-#![doc(html_logo_url =
-    "https://raw.githubusercontent.com/RustCrypto/meta/master/logo_small.png")]
-extern crate subtle;
+#![doc(html_logo_url = "https://raw.githubusercontent.com/RustCrypto/meta/master/logo_small.png")]
 pub extern crate generic_array;
+extern crate subtle;
 
-#[cfg(feature = "std")]
-extern crate std;
 #[cfg(feature = "dev")]
 pub extern crate blobby;
+#[cfg(feature = "std")]
+extern crate std;
 
-use subtle::{Choice, ConstantTimeEq};
-use generic_array::{GenericArray, ArrayLength};
 use generic_array::typenum::Unsigned;
+use generic_array::{ArrayLength, GenericArray};
+use subtle::{Choice, ConstantTimeEq};
 
-mod errors;
 #[cfg(feature = "dev")]
 pub mod dev;
+mod errors;
 
 pub use errors::{InvalidKeyLength, MacError};
 
@@ -73,10 +72,13 @@ pub trait Mac: Clone {
 /// implementation that runs in a fixed time.
 #[derive(Clone)]
 pub struct MacResult<N: ArrayLength<u8>> {
-    code: GenericArray<u8, N>
+    code: GenericArray<u8, N>,
 }
 
-impl<N> MacResult<N> where N: ArrayLength<u8> {
+impl<N> MacResult<N>
+where
+    N: ArrayLength<u8>,
+{
     /// Create a new MacResult.
     pub fn new(code: GenericArray<u8, N>) -> MacResult<N> {
         MacResult { code }
@@ -92,16 +94,22 @@ impl<N> MacResult<N> where N: ArrayLength<u8> {
     }
 }
 
-impl<N> ConstantTimeEq for MacResult<N> where N: ArrayLength<u8> {
+impl<N> ConstantTimeEq for MacResult<N>
+where
+    N: ArrayLength<u8>,
+{
     fn ct_eq(&self, other: &Self) -> Choice {
         self.code.ct_eq(&other.code)
     }
 }
 
-impl<N> PartialEq for MacResult<N> where N: ArrayLength<u8> {
+impl<N> PartialEq for MacResult<N>
+where
+    N: ArrayLength<u8>,
+{
     fn eq(&self, x: &MacResult<N>) -> bool {
         self.ct_eq(x).unwrap_u8() == 1
     }
 }
 
-impl<N> Eq for MacResult<N> where N: ArrayLength<u8> { }
+impl<N> Eq for MacResult<N> where N: ArrayLength<u8> {}