Apply default rust formatting to the tests folders (#2420)

crates/tests/arch_feature/tests/sys.rs

@@ -1,4 +1,7 @@
-use windows_sys::{Win32::System::Diagnostics::Debug::CONTEXT, Win32::System::Environment::VBS_BASIC_ENCLAVE_BASIC_CALL_CREATE_THREAD};
+use windows_sys::{
+    Win32::System::Diagnostics::Debug::CONTEXT,
+    Win32::System::Environment::VBS_BASIC_ENCLAVE_BASIC_CALL_CREATE_THREAD,
+};
 
 #[test]
 #[cfg(target_arch = "x86_64")]

crates/tests/arch_feature/tests/win.rs

@@ -1,4 +1,7 @@
-use windows::{Win32::System::Diagnostics::Debug::CONTEXT, Win32::System::Environment::VBS_BASIC_ENCLAVE_BASIC_CALL_CREATE_THREAD};
+use windows::{
+    Win32::System::Diagnostics::Debug::CONTEXT,
+    Win32::System::Environment::VBS_BASIC_ENCLAVE_BASIC_CALL_CREATE_THREAD,
+};
 
 #[test]
 #[cfg(target_arch = "x86_64")]

crates/tests/array/tests/com.rs

@@ -6,7 +6,14 @@ fn test() -> Result<()> {
         let mut data = std::ptr::null_mut();
         let mut len = 0;
 
-        MFTEnumEx(MFT_CATEGORY_VIDEO_ENCODER, MFT_ENUM_FLAG_HARDWARE, None, None, &mut data, &mut len)?;
+        MFTEnumEx(
+            MFT_CATEGORY_VIDEO_ENCODER,
+            MFT_ENUM_FLAG_HARDWARE,
+            None,
+            None,
+            &mut data,
+            &mut len,
+        )?;
 
         let array = Array::<IMFActivate>::from_raw_parts(data as _, len);
 

crates/tests/bcrypt/tests/sys.rs

@@ -4,46 +4,155 @@ use windows_sys::{Win32::Foundation::*, Win32::Security::Cryptography::*};
 fn test() {
     unsafe {
         let mut rng = 0;
-        assert_eq!(STATUS_SUCCESS, BCryptOpenAlgorithmProvider(&mut rng, BCRYPT_RNG_ALGORITHM, std::ptr::null(), 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptOpenAlgorithmProvider(&mut rng, BCRYPT_RNG_ALGORITHM, std::ptr::null(), 0)
+        );
 
         let mut des = 0;
-        assert_eq!(STATUS_SUCCESS, BCryptOpenAlgorithmProvider(&mut des, BCRYPT_3DES_ALGORITHM, std::ptr::null(), 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptOpenAlgorithmProvider(&mut des, BCRYPT_3DES_ALGORITHM, std::ptr::null(), 0)
+        );
 
         let mut object_len = [0; 4];
         let mut bytes_copied = 0;
-        assert_eq!(STATUS_SUCCESS, BCryptGetProperty(des, BCRYPT_OBJECT_LENGTH, object_len.as_mut_ptr(), object_len.len() as _, &mut bytes_copied, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptGetProperty(
+                des,
+                BCRYPT_OBJECT_LENGTH,
+                object_len.as_mut_ptr(),
+                object_len.len() as _,
+                &mut bytes_copied,
+                0
+            )
+        );
         let object_len = u32::from_le_bytes(object_len);
 
         let mut shared_secret = vec![0; object_len as _];
-        assert_eq!(STATUS_SUCCESS, BCryptGenRandom(rng, shared_secret.as_mut_ptr(), shared_secret.len() as _, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptGenRandom(rng, shared_secret.as_mut_ptr(), shared_secret.len() as _, 0)
+        );
 
         let mut encrypt_key = 0;
-        assert_eq!(STATUS_SUCCESS, BCryptGenerateSymmetricKey(des, &mut encrypt_key, std::ptr::null_mut(), 0, shared_secret.as_ptr(), shared_secret.len() as _, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptGenerateSymmetricKey(
+                des,
+                &mut encrypt_key,
+                std::ptr::null_mut(),
+                0,
+                shared_secret.as_ptr(),
+                shared_secret.len() as _,
+                0
+            )
+        );
 
         let mut block_len = [0; 4];
-        assert_eq!(STATUS_SUCCESS, BCryptGetProperty(des, BCRYPT_BLOCK_LENGTH, block_len.as_mut_ptr(), block_len.len() as _, &mut bytes_copied, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptGetProperty(
+                des,
+                BCRYPT_BLOCK_LENGTH,
+                block_len.as_mut_ptr(),
+                block_len.len() as _,
+                &mut bytes_copied,
+                0
+            )
+        );
         let block_len = u32::from_le_bytes(block_len) as usize;
 
         let send_message = "I ❤️ Rust";
-        let mut send_buffer = vec![0; block_len * ((send_message.len() + (block_len - 1)) / block_len)];
+        let mut send_buffer =
+            vec![0; block_len * ((send_message.len() + (block_len - 1)) / block_len)];
         send_buffer[..send_message.len()].copy_from_slice(send_message.as_bytes());
 
         let mut encrypted_len = 0;
-        assert_eq!(STATUS_SUCCESS, BCryptEncrypt(encrypt_key, send_buffer.as_ptr(), send_buffer.len() as _, std::ptr::null(), std::ptr::null_mut(), 0, std::ptr::null_mut(), 0, &mut encrypted_len, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptEncrypt(
+                encrypt_key,
+                send_buffer.as_ptr(),
+                send_buffer.len() as _,
+                std::ptr::null(),
+                std::ptr::null_mut(),
+                0,
+                std::ptr::null_mut(),
+                0,
+                &mut encrypted_len,
+                0
+            )
+        );
 
         let mut encrypted = vec![0; encrypted_len as _];
-        assert_eq!(STATUS_SUCCESS, BCryptEncrypt(encrypt_key, send_buffer.as_ptr(), send_buffer.len() as _, std::ptr::null(), std::ptr::null_mut(), 0, encrypted.as_mut_ptr(), encrypted.len() as _, &mut encrypted_len, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptEncrypt(
+                encrypt_key,
+                send_buffer.as_ptr(),
+                send_buffer.len() as _,
+                std::ptr::null(),
+                std::ptr::null_mut(),
+                0,
+                encrypted.as_mut_ptr(),
+                encrypted.len() as _,
+                &mut encrypted_len,
+                0
+            )
+        );
 
         let mut decrypt_key = 0;
-        assert_eq!(STATUS_SUCCESS, BCryptGenerateSymmetricKey(des, &mut decrypt_key, std::ptr::null_mut(), 0, shared_secret.as_ptr(), shared_secret.len() as _, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptGenerateSymmetricKey(
+                des,
+                &mut decrypt_key,
+                std::ptr::null_mut(),
+                0,
+                shared_secret.as_ptr(),
+                shared_secret.len() as _,
+                0
+            )
+        );
 
         let mut decrypted_len = 0;
-        assert_eq!(STATUS_SUCCESS, BCryptDecrypt(decrypt_key, encrypted.as_ptr(), encrypted.len() as _, std::ptr::null(), std::ptr::null_mut(), 0, std::ptr::null_mut(), 0, &mut decrypted_len, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptDecrypt(
+                decrypt_key,
+                encrypted.as_ptr(),
+                encrypted.len() as _,
+                std::ptr::null(),
+                std::ptr::null_mut(),
+                0,
+                std::ptr::null_mut(),
+                0,
+                &mut decrypted_len,
+                0
+            )
+        );
 
         let mut decrypted = vec![0; decrypted_len as _];
-        assert_eq!(STATUS_SUCCESS, BCryptDecrypt(decrypt_key, encrypted.as_ptr(), encrypted.len() as _, std::ptr::null(), std::ptr::null_mut(), 0, decrypted.as_mut_ptr(), decrypted.len() as _, &mut decrypted_len, 0));
+        assert_eq!(
+            STATUS_SUCCESS,
+            BCryptDecrypt(
+                decrypt_key,
+                encrypted.as_ptr(),
+                encrypted.len() as _,
+                std::ptr::null(),
+                std::ptr::null_mut(),
+                0,
+                decrypted.as_mut_ptr(),
+                decrypted.len() as _,
+                &mut decrypted_len,
+                0
+            )
+        );
 
-        let receive_message = std::str::from_utf8(trim_null_end(&decrypted)).expect("Not a valid message");
+        let receive_message =
+            std::str::from_utf8(trim_null_end(&decrypted)).expect("Not a valid message");
         assert_eq!(send_message, receive_message);
     }
 }

crates/tests/bcrypt/tests/win.rs

@@ -11,7 +11,13 @@ fn test() -> Result<()> {
 
         let mut object_len = [0; 4];
         let mut bytes_copied = 0;
-        BCryptGetProperty(des, BCRYPT_OBJECT_LENGTH, Some(&mut object_len), &mut bytes_copied, 0)?;
+        BCryptGetProperty(
+            des,
+            BCRYPT_OBJECT_LENGTH,
+            Some(&mut object_len),
+            &mut bytes_copied,
+            0,
+        )?;
         let object_len = u32::from_le_bytes(object_len);
 
         let mut shared_secret = vec![0; object_len as _];
@@ -21,29 +27,69 @@ fn test() -> Result<()> {
         BCryptGenerateSymmetricKey(des, &mut encrypt_key, None, &shared_secret, 0)?;
 
         let mut block_len = [0; 4];
-        BCryptGetProperty(des, BCRYPT_BLOCK_LENGTH, Some(&mut block_len), &mut bytes_copied, 0)?;
+        BCryptGetProperty(
+            des,
+            BCRYPT_BLOCK_LENGTH,
+            Some(&mut block_len),
+            &mut bytes_copied,
+            0,
+        )?;
         let block_len = u32::from_le_bytes(block_len) as usize;
 
         let send_message = "I ❤️ Rust";
-        let mut send_buffer = vec![0; block_len * ((send_message.len() + (block_len - 1)) / block_len)];
+        let mut send_buffer =
+            vec![0; block_len * ((send_message.len() + (block_len - 1)) / block_len)];
         send_buffer[..send_message.len()].copy_from_slice(send_message.as_bytes());
 
         let mut encrypted_len = 0;
-        BCryptEncrypt(encrypt_key, Some(&send_buffer), None, None, None, &mut encrypted_len, Default::default())?;
+        BCryptEncrypt(
+            encrypt_key,
+            Some(&send_buffer),
+            None,
+            None,
+            None,
+            &mut encrypted_len,
+            Default::default(),
+        )?;
 
         let mut encrypted = vec![0; encrypted_len as _];
-        BCryptEncrypt(encrypt_key, Some(&send_buffer), None, None, Some(&mut encrypted), &mut encrypted_len, Default::default())?;
+        BCryptEncrypt(
+            encrypt_key,
+            Some(&send_buffer),
+            None,
+            None,
+            Some(&mut encrypted),
+            &mut encrypted_len,
+            Default::default(),
+        )?;
 
         let mut decrypt_key = Default::default();
         BCryptGenerateSymmetricKey(des, &mut decrypt_key, None, &shared_secret, 0)?;
 
         let mut decrypted_len = 0;
-        BCryptDecrypt(decrypt_key, Some(&encrypted), None, None, None, &mut decrypted_len, Default::default())?;
+        BCryptDecrypt(
+            decrypt_key,
+            Some(&encrypted),
+            None,
+            None,
+            None,
+            &mut decrypted_len,
+            Default::default(),
+        )?;
 
         let mut decrypted = vec![0; decrypted_len as _];
-        BCryptDecrypt(decrypt_key, Some(&encrypted), None, None, Some(&mut decrypted), &mut decrypted_len, Default::default())?;
+        BCryptDecrypt(
+            decrypt_key,
+            Some(&encrypted),
+            None,
+            None,
+            Some(&mut decrypted),
+            &mut decrypted_len,
+            Default::default(),
+        )?;
 
-        let receive_message = std::str::from_utf8(trim_null_end(&decrypted)).expect("Not a valid message");
+        let receive_message =
+            std::str::from_utf8(trim_null_end(&decrypted)).expect("Not a valid message");
         assert_eq!(send_message, receive_message);
     }
     Ok(())

crates/tests/calling_convention/tests/sys.rs

@@ -1,4 +1,6 @@
-use windows_sys::{Win32::Foundation::*, Win32::Networking::Ldap::*, Win32::System::SystemInformation::*};
+use windows_sys::{
+    Win32::Foundation::*, Win32::Networking::Ldap::*, Win32::System::SystemInformation::*,
+};
 
 #[test]
 fn calling_convention() {

crates/tests/calling_convention/tests/win.rs

@@ -1,4 +1,6 @@
-use windows::{Win32::Foundation::*, Win32::Networking::Ldap::*, Win32::System::SystemInformation::*};
+use windows::{
+    Win32::Foundation::*, Win32::Networking::Ldap::*, Win32::System::SystemInformation::*,
+};
 
 #[test]
 fn calling_convention() {

crates/tests/collections/tests/stock_iterable.rs

@@ -8,7 +8,11 @@ fn calendar() -> Result<()> {
     use windows::Globalization::*;
 
     let languages = IIterable::try_from(vec![HSTRING::from("he-IL"), HSTRING::from("ja-JP")])?;
-    let calendar = Calendar::CreateCalendar(&languages, &CalendarIdentifiers::Hebrew()?, &ClockIdentifiers::TwentyFourHour()?)?;
+    let calendar = Calendar::CreateCalendar(
+        &languages,
+        &CalendarIdentifiers::Hebrew()?,
+        &ClockIdentifiers::TwentyFourHour()?,
+    )?;
 
     let languages2 = calendar.Languages()?;
     assert_eq!(languages2.Size()?, 2);
@@ -98,7 +102,11 @@ fn hstring() -> Result<()> {
     values.resize_with(5, Default::default);
     assert_eq!(iter.GetMany(&mut values)?, 0);
 
-    let able = IIterable::<HSTRING>::try_from(vec![HSTRING::from("one"), HSTRING::from("two"), HSTRING::from("three")])?;
+    let able = IIterable::<HSTRING>::try_from(vec![
+        HSTRING::from("one"),
+        HSTRING::from("two"),
+        HSTRING::from("three"),
+    ])?;
     let iter = able.First()?;
 
     assert_eq!(&iter.Current()?, h!("one"));
@@ -130,7 +138,16 @@ fn hstring() -> Result<()> {
     let mut values = vec![];
     values.resize_with(5, Default::default);
     assert_eq!(iter.GetMany(&mut values)?, 3);
-    assert_eq!(values, [HSTRING::from("one"), HSTRING::from("two"), HSTRING::from("three"), HSTRING::default(), HSTRING::default()]);
+    assert_eq!(
+        values,
+        [
+            HSTRING::from("one"),
+            HSTRING::from("two"),
+            HSTRING::from("three"),
+            HSTRING::default(),
+            HSTRING::default()
+        ]
+    );
     assert_eq!(iter.GetMany(&mut values)?, 0);
 
     let iter = able.First()?;
@@ -178,7 +195,11 @@ fn defaulted() -> Result<()> {
     values.resize(5, None);
     assert_eq!(iter.GetMany(&mut values)?, 0);
 
-    let able = IIterable::<IStringable>::try_from(vec![Some(stringable("one")), Some(stringable("two")), Some(stringable("three"))])?;
+    let able = IIterable::<IStringable>::try_from(vec![
+        Some(stringable("one")),
+        Some(stringable("two")),
+        Some(stringable("three")),
+    ])?;
     let iter = able.First()?;
 
     assert_eq!(iter.Current()?.ToString()?, "one");

crates/tests/component/build.rs

@@ -7,14 +7,28 @@ fn main() -> std::io::Result<()> {
     std::fs::create_dir_all(".windows/winmd")?;
 
     let mut command = Command::new("midlrt.exe");
-    command.arg("/winrt").arg("/nomidl").arg("/h").arg("nul").arg("/metadata_dir").arg(&metadata_dir).arg("/reference").arg(format!("{metadata_dir}\\Windows.Foundation.winmd")).arg("/winmd").arg(".windows/winmd/component.winmd").arg("src/component.idl");
+    command
+        .arg("/winrt")
+        .arg("/nomidl")
+        .arg("/h")
+        .arg("nul")
+        .arg("/metadata_dir")
+        .arg(&metadata_dir)
+        .arg("/reference")
+        .arg(format!("{metadata_dir}\\Windows.Foundation.winmd"))
+        .arg("/winmd")
+        .arg(".windows/winmd/component.winmd")
+        .arg("src/component.idl");
 
     if !command.status()?.success() {
         panic!();
     }
 
     let files = metadata::reader::File::with_default(&[".windows/winmd/component.winmd"])?;
-    write("src/bindings.rs", bindgen::component("test_component", &files))?;
+    write(
+        "src/bindings.rs",
+        bindgen::component("test_component", &files),
+    )?;
     Command::new("rustfmt").arg("src/bindings.rs").status()?;
 
     Ok(())