fmt

Author: Vaiz

crates/nfs3_types/tests/collections.rs

@@ -90,7 +90,7 @@ fn empty_collections() {
     let len = empty_vec.pack(&mut buffer).unwrap();
     assert_eq!(len, 4); // Just the length field
     assert_eq!(buffer, [0, 0, 0, 0]);
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, len) = Vec::<u32>::unpack(&mut cursor).unwrap();
     assert_eq!(len, 4);
@@ -102,7 +102,7 @@ fn empty_collections() {
     let len = empty_list.pack(&mut buffer).unwrap();
     assert_eq!(len, 4); // Just the end marker
     assert_eq!(buffer, [0, 0, 0, 0]);
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, len) = List::<u32>::unpack(&mut cursor).unwrap();
     assert_eq!(len, 4);
@@ -117,7 +117,7 @@ fn single_item_collections() {
     let len = single_vec.pack(&mut buffer).unwrap();
     assert_eq!(len, 8); // 4 bytes length + 4 bytes data
     assert_eq!(buffer, [0, 0, 0, 1, 0x12, 0x34, 0x56, 0x78]);
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, len) = Vec::<u32>::unpack(&mut cursor).unwrap();
     assert_eq!(len, 8);
@@ -129,7 +129,7 @@ fn single_item_collections() {
     let len = single_list.pack(&mut buffer).unwrap();
     assert_eq!(len, 12); // 4 bytes indicator + 4 bytes data + 4 bytes end marker
     assert_eq!(buffer, [0, 0, 0, 1, 0x12, 0x34, 0x56, 0x78, 0, 0, 0, 0]);
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, len) = List::<u32>::unpack(&mut cursor).unwrap();
     assert_eq!(len, 12);
@@ -142,13 +142,13 @@ fn bounded_list_edge_cases() {
     // Even zero size should have the end marker, so it should be at least 4
     let mut bounded_list = BoundedList::<u32>::new(4); // Just end marker
     assert!(bounded_list.try_push(0x1234).is_err());
-    
+
     // Test with exactly one item size
     // Each item needs 4 bytes indicator + 4 bytes data, plus 4 bytes end marker = 12 bytes total
     let mut bounded_list = BoundedList::<u32>::new(12);
     assert!(bounded_list.try_push(0x1234).is_ok());
     assert!(bounded_list.try_push(0x5678).is_err());
-    
+
     let list = bounded_list.into_inner();
     assert_eq!(list.0, vec![0x1234]);
 }
@@ -160,12 +160,12 @@ fn large_collections() {
     let mut buffer = Vec::new();
     let len = large_vec.pack(&mut buffer).unwrap();
     assert_eq!(len, 404); // 4 bytes length + 100 * 4 bytes data
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, len) = Vec::<u32>::unpack(&mut cursor).unwrap();
     assert_eq!(len, 404);
     assert_eq!(large_vec, deserialized);
-    
+
     // Test bounded list with many items
     // Each item needs 4 bytes indicator + 4 bytes data = 8 bytes per item
     // Plus 4 bytes for the end marker
@@ -175,7 +175,7 @@ fn large_collections() {
         assert!(bounded_list.try_push(i).is_ok(), "Failed to push item {i}");
     }
     assert!(bounded_list.try_push(100).is_err()); // Should fail on 101st item
-    
+
     let list = bounded_list.into_inner();
     assert_eq!(list.0.len(), 100);
     assert_eq!(list.0, (0..100).collect::<Vec<u32>>());

crates/nfs3_types/tests/nfs3_types.rs

@@ -169,14 +169,14 @@ fn filename3_edge_cases() {
     let len = empty_name.pack(&mut buffer).unwrap();
     assert_eq!(len, 4); // Just the length field
     assert_eq!(buffer, [0, 0, 0, 0]);
-    
+
     // Test single character filename
     let single_char = filename3::from(&b"a"[..]);
     let mut buffer = Vec::new();
     let len = single_char.pack(&mut buffer).unwrap();
     assert_eq!(len, 8); // 4 bytes length + 1 byte data + 3 bytes padding
     assert_eq!(buffer, [0, 0, 0, 1, b'a', 0, 0, 0]);
-    
+
     // Test filename requiring no padding (multiple of 4)
     let quad_name = filename3::from(&b"test"[..]);
     let mut buffer = Vec::new();
@@ -192,48 +192,48 @@ fn nfs3_result_roundtrip() {
         Nfs3Result::<Void, Void>::Ok(Void),
         Nfs3Result::<Void, Void>::Err((nfsstat3::NFS3ERR_PERM, Void)),
     ];
-    
+
     for original in void_cases {
         let mut buffer = Vec::new();
         let pack_len = original.pack(&mut buffer).unwrap();
         assert_eq!(pack_len, original.packed_size());
-        
+
         let mut cursor = Cursor::new(buffer);
         let (deserialized, unpack_len) = Nfs3Result::<Void, Void>::unpack(&mut cursor).unwrap();
         assert_eq!(pack_len, unpack_len);
         // Compare the discriminant and data separately since Nfs3Result doesn't implement PartialEq
         match (&original, &deserialized) {
-            (Nfs3Result::Ok(_), Nfs3Result::Ok(_)) => {},
+            (Nfs3Result::Ok(_), Nfs3Result::Ok(_)) => {}
             (Nfs3Result::Err((status1, _)), Nfs3Result::Err((status2, _))) => {
                 assert_eq!(status1, status2);
-            },
+            }
             _ => panic!("Roundtrip mismatch"),
         }
     }
-    
+
     // Test u32 cases
     let u32_cases = [
         Nfs3Result::<u32, u32>::Ok(0x1234_5678),
         Nfs3Result::<u32, u32>::Err((nfsstat3::NFS3ERR_NOENT, 0x8765_4321)),
     ];
-    
+
     for original in u32_cases {
         let mut buffer = Vec::new();
         let pack_len = original.pack(&mut buffer).unwrap();
         assert_eq!(pack_len, original.packed_size());
-        
+
         let mut cursor = Cursor::new(buffer);
         let (deserialized, unpack_len) = Nfs3Result::<u32, u32>::unpack(&mut cursor).unwrap();
         assert_eq!(pack_len, unpack_len);
         // Compare the discriminant and data separately
         match (&original, &deserialized) {
             (Nfs3Result::Ok(val1), Nfs3Result::Ok(val2)) => {
                 assert_eq!(val1, val2);
-            },
+            }
             (Nfs3Result::Err((status1, val1)), Nfs3Result::Err((status2, val2))) => {
                 assert_eq!(status1, status2);
                 assert_eq!(val1, val2);
-            },
+            }
             _ => panic!("Roundtrip mismatch"),
         }
     }
@@ -272,34 +272,34 @@ fn nfs3_error_codes() {
         nfsstat3::NFS3ERR_BADTYPE,
         nfsstat3::NFS3ERR_JUKEBOX,
     ];
-    
+
     for error_code in error_codes {
         let result = Nfs3Result::<Void, Void>::Err((error_code, Void));
         let mut buffer = Vec::new();
         let len = result.pack(&mut buffer).unwrap();
         assert_eq!(len, 4);
-        
+
         let mut cursor = Cursor::new(buffer);
         let (deserialized, _) = Nfs3Result::<Void, Void>::unpack(&mut cursor).unwrap();
         // Compare error codes manually since Nfs3Result doesn't implement PartialEq
         match deserialized {
             Nfs3Result::Err((deserialized_code, _)) => {
                 assert_eq!(error_code as u32, deserialized_code as u32);
-            },
+            }
             Nfs3Result::Ok(_) => panic!("Expected error result for error code {error_code:?}"),
         }
     }
-    
+
     // Test NFS3_OK separately as a success case
     let success_result = Nfs3Result::<Void, Void>::Ok(Void);
     let mut buffer = Vec::new();
     let len = success_result.pack(&mut buffer).unwrap();
     assert_eq!(len, 4);
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, _) = Nfs3Result::<Void, Void>::unpack(&mut cursor).unwrap();
     match deserialized {
-        Nfs3Result::Ok(_) => {}, // Expected success
+        Nfs3Result::Ok(_) => {} // Expected success
         Nfs3Result::Err(_) => panic!("Expected success result for NFS3_OK"),
     }
 }

crates/nfs3_types/tests/rpc_mount.rs

@@ -133,39 +133,39 @@ fn mount3res_roundtrip() {
         fhandle: fhandle3(Opaque(Cow::Borrowed(&[0x12, 0x34, 0x56, 0x78]))),
         auth_flavors: vec![1, 2, 3],
     });
-    
+
     let mut buffer = Vec::new();
     let pack_len = success_res.pack(&mut buffer).unwrap();
     assert_eq!(pack_len, success_res.packed_size());
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, unpack_len) = mountres3::unpack(&mut cursor).unwrap();
     assert_eq!(pack_len, unpack_len);
-    
+
     match (&success_res, &deserialized) {
         (mountres3::Ok(ok1), mountres3::Ok(ok2)) => {
             assert_eq!(ok1.fhandle.0.as_ref(), ok2.fhandle.0.as_ref());
             assert_eq!(ok1.auth_flavors, ok2.auth_flavors);
         }
         _ => panic!("Expected success response"),
     }
-    
+
     // Test error mount response
     let error_res = mountres3::Err(mountstat3::MNT3ERR_PERM);
     let mut buffer = Vec::new();
     let pack_len = error_res.pack(&mut buffer).unwrap();
     assert_eq!(pack_len, error_res.packed_size());
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, unpack_len) = mountres3::unpack(&mut cursor).unwrap();
     assert_eq!(pack_len, unpack_len);
     match (&error_res, &deserialized) {
-            (mountres3::Err(err1), mountres3::Err(err2)) => {
-                // Compare error codes by their discriminant values
-                assert_eq!(*err1 as u32, *err2 as u32);
-            }
-            _ => panic!("Expected error response"),
+        (mountres3::Err(err1), mountres3::Err(err2)) => {
+            // Compare error codes by their discriminant values
+            assert_eq!(*err1 as u32, *err2 as u32);
         }
+        _ => panic!("Expected error response"),
+    }
 }
 
 #[test]
@@ -176,7 +176,7 @@ fn fhandle3_edge_cases() {
     let len = empty_fh.pack(&mut buffer).unwrap();
     assert_eq!(len, 4); // Just the length field
     assert_eq!(buffer, [0, 0, 0, 0]);
-    
+
     // Test maximum size file handle (64 bytes)
     let max_data = vec![0x42; 64];
     let max_fh = fhandle3(Opaque(Cow::Borrowed(&max_data)));
@@ -192,7 +192,7 @@ fn opaque_auth_default() {
     let len = auth.pack(&mut buffer).unwrap();
     assert_eq!(len, 8); // 4 bytes flavor + 4 bytes length (no data)
     assert_eq!(buffer, [0, 0, 0, 0, 0, 0, 0, 0]);
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, unpack_len) = opaque_auth::unpack(&mut cursor).unwrap();
     assert_eq!(len, unpack_len);
@@ -206,12 +206,12 @@ fn opaque_auth_with_data() {
         flavor: auth_flavor::AUTH_UNIX,
         body: Opaque(Cow::Borrowed(&[0x12, 0x34, 0x56, 0x78])),
     };
-    
+
     let mut buffer = Vec::new();
     let len = auth.pack(&mut buffer).unwrap();
     assert_eq!(len, 12); // 4 bytes flavor + 4 bytes length + 4 bytes data
     assert_eq!(buffer, [0, 0, 0, 1, 0, 0, 0, 4, 0x12, 0x34, 0x56, 0x78]);
-    
+
     let mut cursor = Cursor::new(buffer);
     let (deserialized, unpack_len) = opaque_auth::unpack(&mut cursor).unwrap();
     assert_eq!(len, unpack_len);
@@ -232,23 +232,23 @@ fn mount_error_codes() {
         mountstat3::MNT3ERR_NOTSUPP,
         mountstat3::MNT3ERR_SERVERFAULT,
     ];
-    
+
     for error_code in error_codes {
         let res = mountres3::Err(error_code);
         let mut buffer = Vec::new();
         let len = res.pack(&mut buffer).unwrap();
         assert_eq!(len, 4);
-        
+
         let mut cursor = Cursor::new(buffer);
         let (deserialized, _) = mountres3::unpack(&mut cursor).unwrap();
         match deserialized {
             mountres3::Err(deserialized_code) => {
                 assert_eq!(error_code as u32, deserialized_code as u32);
-            },
+            }
             mountres3::Ok(_) => panic!("Expected error result for error code {error_code:?}"),
         }
     }
-    
+
     // Test MNT3_OK separately as a success case would require a valid mount response
     // which is more complex, so we'll skip it in this simple error code test
 }
@@ -257,7 +257,7 @@ fn mount_error_codes() {
 fn rpc_program_constants() {
     // Test that common RPC program numbers are correctly defined
     assert_eq!(RPC_VERSION_2, 2);
-    
+
     // Test typical NFS program numbers (these might be defined elsewhere)
     let call = call_body {
         rpcvers: RPC_VERSION_2,
@@ -267,7 +267,7 @@ fn rpc_program_constants() {
         cred: opaque_auth::default(),
         verf: opaque_auth::default(),
     };
-    
+
     assert_eq!(call.prog, 100_003);
     assert_eq!(call.vers, 3);
     assert_eq!(call.rpcvers, RPC_VERSION_2);
@@ -282,17 +282,17 @@ fn auth_flavors() {
         auth_flavor::AUTH_SHORT,
         auth_flavor::AUTH_DES,
     ];
-    
+
     for flavor in auth_flavors {
         let auth = opaque_auth {
             flavor,
             body: Opaque(Cow::Borrowed(&[])),
         };
-        
+
         let mut buffer = Vec::new();
         let len = auth.pack(&mut buffer).unwrap();
         assert_eq!(len, 8); // 4 bytes flavor + 4 bytes length
-        
+
         let mut cursor = Cursor::new(buffer);
         let (deserialized, _) = opaque_auth::unpack(&mut cursor).unwrap();
         assert_eq!(auth.flavor, deserialized.flavor);