style: cargo fmt kernel crates

crates/kernel/src/proofs/delegation.rs

@@ -1,6 +1,6 @@
+use super::{arbitrary_endpoint_cap, insert_cap};
 use domain::capability::{Capability, CapabilityTable};
 use domain::resource::Resource;
-use super::{arbitrary_endpoint_cap, insert_cap};
 use types::generation::Generation;
 use types::id::EndpointId;
 use types::permission::{Permission, PermissionSet};
@@ -16,17 +16,16 @@ fn kernel_delegate_path_never_escalates() {
     kani::assume(source_perms.allows(Permission::Delegate));
 
     let mut source_table = CapabilityTable::new();
-    let slot = insert_cap(&mut source_table, arbitrary_endpoint_cap(source_bits, ep_id));
+    let slot = insert_cap(
+        &mut source_table,
+        arbitrary_endpoint_cap(source_bits, ep_id),
+    );
 
     let cap = source_table.get(slot).unwrap();
     let original_perms = *cap.permissions();
     let restricted = original_perms.restrict_to(&PermissionSet::from_bits(restrict_bits));
 
-    let delegated = Capability::new(
-        cap.resource().clone(),
-        restricted,
-        Generation::initial(),
-    );
+    let delegated = Capability::new(cap.resource().clone(), restricted, Generation::initial());
 
     let mut target_table = CapabilityTable::new();
     let target_slot = insert_cap(&mut target_table, delegated);
@@ -34,11 +33,21 @@ fn kernel_delegate_path_never_escalates() {
     let result = target_table.get(target_slot).unwrap();
     assert!(result.permissions().is_subset_of(&original_perms));
 
-    if !original_perms.allows(Permission::Read) { assert!(!result.permissions().allows(Permission::Read)); }
-    if !original_perms.allows(Permission::Write) { assert!(!result.permissions().allows(Permission::Write)); }
-    if !original_perms.allows(Permission::Execute) { assert!(!result.permissions().allows(Permission::Execute)); }
-    if !original_perms.allows(Permission::Delegate) { assert!(!result.permissions().allows(Permission::Delegate)); }
-    if !original_perms.allows(Permission::Revoke) { assert!(!result.permissions().allows(Permission::Revoke)); }
+    if !original_perms.allows(Permission::Read) {
+        assert!(!result.permissions().allows(Permission::Read));
+    }
+    if !original_perms.allows(Permission::Write) {
+        assert!(!result.permissions().allows(Permission::Write));
+    }
+    if !original_perms.allows(Permission::Execute) {
+        assert!(!result.permissions().allows(Permission::Execute));
+    }
+    if !original_perms.allows(Permission::Delegate) {
+        assert!(!result.permissions().allows(Permission::Delegate));
+    }
+    if !original_perms.allows(Permission::Revoke) {
+        assert!(!result.permissions().allows(Permission::Revoke));
+    }
 }
 
 #[kani::proof]
@@ -58,7 +67,9 @@ fn kernel_chained_delegate_never_escalates() {
     let slot_a = insert_cap(&mut table_a, arbitrary_endpoint_cap(original_bits, ep_id));
 
     let cap = table_a.get(slot_a).unwrap();
-    let perms_for_b = cap.permissions().restrict_to(&PermissionSet::from_bits(restrict1_bits));
+    let perms_for_b = cap
+        .permissions()
+        .restrict_to(&PermissionSet::from_bits(restrict1_bits));
 
     let mut table_b = CapabilityTable::new();
     let cap_b = Capability::new(resource.clone(), perms_for_b, Generation::initial());
@@ -66,7 +77,9 @@ fn kernel_chained_delegate_never_escalates() {
 
     let cap_in_b = table_b.get(slot_b).unwrap();
     if cap_in_b.permissions().allows(Permission::Delegate) {
-        let perms_for_c = cap_in_b.permissions().restrict_to(&PermissionSet::from_bits(restrict2_bits));
+        let perms_for_c = cap_in_b
+            .permissions()
+            .restrict_to(&PermissionSet::from_bits(restrict2_bits));
 
         let mut table_c = CapabilityTable::new();
         let cap_c = Capability::new(resource, perms_for_c, Generation::initial());

crates/kernel/src/proofs/mediation.rs

@@ -1,5 +1,5 @@
-use domain::capability::CapabilityTable;
 use super::{arbitrary_endpoint_cap, insert_cap};
+use domain::capability::CapabilityTable;
 use types::bounded::CapSlot;
 use types::permission::{Permission, PermissionSet};
 
@@ -60,7 +60,11 @@ fn check_cap_faithfully_reflects_stored_permissions() {
 
     assert!(retrieved.permissions().allows(Permission::Read) == perms.allows(Permission::Read));
     assert!(retrieved.permissions().allows(Permission::Write) == perms.allows(Permission::Write));
-    assert!(retrieved.permissions().allows(Permission::Execute) == perms.allows(Permission::Execute));
-    assert!(retrieved.permissions().allows(Permission::Delegate) == perms.allows(Permission::Delegate));
+    assert!(
+        retrieved.permissions().allows(Permission::Execute) == perms.allows(Permission::Execute)
+    );
+    assert!(
+        retrieved.permissions().allows(Permission::Delegate) == perms.allows(Permission::Delegate)
+    );
     assert!(retrieved.permissions().allows(Permission::Revoke) == perms.allows(Permission::Revoke));
 }

crates/kernel/src/proofs/revocation.rs

@@ -1,7 +1,7 @@
+use super::{arbitrary_endpoint_cap, insert_cap};
 use domain::capability::{Capability, CapabilityTable};
 use domain::endpoint::Endpoint;
 use domain::resource::Resource;
-use super::{arbitrary_endpoint_cap, insert_cap};
 use types::generation::Generation;
 use types::id::EndpointId;
 use types::permission::{Permission, PermissionSet};
@@ -81,12 +81,24 @@ fn generation_revocation_invalidates_all_caps() {
     let mut table = CapabilityTable::new();
     let slot = insert_cap(&mut table, cap);
 
-    assert!(table.get(slot).unwrap().generation().is_valid_against(&original_gen));
+    assert!(
+        table
+            .get(slot)
+            .unwrap()
+            .generation()
+            .is_valid_against(&original_gen)
+    );
 
     endpoint.revoke();
     let new_gen = *endpoint.generation();
 
-    assert!(!table.get(slot).unwrap().generation().is_valid_against(&new_gen));
+    assert!(
+        !table
+            .get(slot)
+            .unwrap()
+            .generation()
+            .is_valid_against(&new_gen)
+    );
 }
 
 #[kani::proof]