Warnings in tests fixed

spirali · spirali · commit 080856d8e021 · 2026-03-25T16:22:38.000+01:00
diff --git a/crates/tako/src/internal/scheduler/gap_cache.rs b/crates/tako/src/internal/scheduler/gap_cache.rs
@@ -160,11 +160,11 @@ fn compute_gap(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::internal::server::workerload::WorkerResources;
-    use crate::resources::ResourceRequestVariants;
+    
+    
     use crate::tests::utils::env::TestEnv;
     use crate::tests::utils::resources::ResBuilder;
-    use crate::tests::utils::task::TaskBuilder;
+    
     use crate::tests::utils::worker::WorkerBuilder;
 
     #[test]
diff --git a/crates/tako/src/internal/server/core.rs b/crates/tako/src/internal/server/core.rs
@@ -511,11 +511,11 @@ impl Core {
 mod tests {
     use crate::internal::server::core::Core;
     use crate::internal::server::task::Task;
-    use crate::internal::server::task::TaskRuntimeState;
+    
     use crate::internal::server::worker::Worker;
     use crate::internal::server::workergroup::WorkerGroup;
 
-    use crate::tests::utils::env::TestEnv;
+    
 
     use crate::{TaskId, WorkerId};
 
diff --git a/crates/tako/src/internal/tests/test_reactor.rs b/crates/tako/src/internal/tests/test_reactor.rs
@@ -1,9 +1,8 @@
 use crate::gateway::LostWorkerReason;
 use crate::internal::common::resources::ResourceDescriptor;
 use crate::internal::messages::common::TaskFailInfo;
-use crate::internal::messages::worker::FromWorkerMessage::TaskUpdate;
 use crate::internal::messages::worker::{
-    ComputeTasksMsg, NewWorkerMsg, TaskIdsMsg, TaskUpdates, ToWorkerMessage, WorkerTaskUpdate,
+    ComputeTasksMsg, NewWorkerMsg, TaskIdsMsg, ToWorkerMessage, WorkerTaskUpdate,
 };
 use crate::internal::scheduler::SchedulerConfig;
 use crate::internal::server::core::Core;
diff --git a/crates/tako/src/internal/tests/test_scheduler_mapping.rs b/crates/tako/src/internal/tests/test_scheduler_mapping.rs
@@ -1,7 +1,5 @@
-use crate::ResourceVariantId;
 use crate::internal::server::task::TaskRuntimeState;
-use crate::tests::utils::env::{TestComm, TestEnv};
-use crate::tests::utils::scheduler::TestCase;
+use crate::tests::utils::env::TestEnv;
 use crate::tests::utils::task::TaskBuilder;
 use crate::tests::utils::worker::WorkerBuilder;
 
@@ -41,7 +39,7 @@ fn test_schedule_mapping_do_not_change() {
     assert!(m.workers.is_empty());
 
     let _w3 = rt.new_worker_cpus(6);
-    let t2 = rt.new_task(&TaskBuilder::new().cpus(4).add_resource(1, 2));
+    let _t2 = rt.new_task(&TaskBuilder::new().cpus(4).add_resource(1, 2));
     let m = rt.schedule_mapping();
     assert!(m.workers.is_empty());
 }
diff --git a/crates/tako/src/internal/tests/test_scheduler_mn.rs b/crates/tako/src/internal/tests/test_scheduler_mn.rs
@@ -2,10 +2,8 @@ use crate::WorkerId;
 use crate::internal::messages::worker::ToWorkerMessage;
 use crate::internal::scheduler::create_task_batches;
 use crate::internal::server::task::Task;
-use crate::resources::ResourceAmount;
 use crate::tests::utils::env::{TestComm, TestEnv};
 use crate::tests::utils::resources::ResBuilder;
-use crate::tests::utils::scheduler::TestCase;
 use crate::tests::utils::task::TaskBuilder;
 use crate::tests::utils::worker::WorkerBuilder;
 use std::time::Duration;
@@ -75,7 +73,7 @@ fn test_mn_task_batches1() {
 fn test_mn_task_batches2() {
     let mut rt = TestEnv::new();
     let now = std::time::Instant::now();
-    let ws = rt.new_workers_cpus(&[1, 1, 1]);
+    let _ws = rt.new_workers_cpus(&[1, 1, 1]);
 
     rt.new_task(&TaskBuilder::new().user_priority(0).n_nodes(3));
     rt.new_task(&TaskBuilder::new().user_priority(5).n_nodes(2));
diff --git a/crates/tako/src/internal/tests/test_scheduler_sn.rs b/crates/tako/src/internal/tests/test_scheduler_sn.rs
@@ -3,12 +3,11 @@ use crate::internal::scheduler::{PriorityCut, SchedulerConfig, create_task_batch
 use crate::internal::server::reactor::on_retract_response;
 use crate::internal::server::task::TaskRuntimeState;
 use crate::internal::tests::utils::scheduler::TestCase;
-use crate::internal::worker::comm::WorkerComm::Test;
 use crate::resources::ResourceRqId;
 use crate::tests::utils::env::{TestComm, TestEnv};
 use crate::tests::utils::task::TaskBuilder;
 use crate::tests::utils::worker::WorkerBuilder;
-use crate::{Priority, ResourceVariantId, TaskId, WorkerId};
+use crate::{ResourceVariantId, WorkerId};
 use std::time::Duration;
 
 #[test]
@@ -28,10 +27,10 @@ fn test_task_grouping_basic() {
     assert_eq!(a[0].size, 1);
     assert!(!a[0].limit_reached);
 
-    let t2 = rt.new_task(&TaskBuilder::new().user_priority(20));
-    let t3 = rt.new_task(&TaskBuilder::new().user_priority(5));
-    let t4 = rt.new_task(&TaskBuilder::new().user_priority(123));
-    let t5 = rt.new_task(&TaskBuilder::new().user_priority(20));
+    let _t2 = rt.new_task(&TaskBuilder::new().user_priority(20));
+    let _t3 = rt.new_task(&TaskBuilder::new().user_priority(5));
+    let _t4 = rt.new_task(&TaskBuilder::new().user_priority(123));
+    let _t5 = rt.new_task(&TaskBuilder::new().user_priority(20));
 
     let a = create_task_batches(rt.core(), now, None);
     assert_eq!(a.len(), 1);
@@ -43,8 +42,8 @@ fn test_task_grouping_basic() {
 
     let t6 = rt.new_task(&TaskBuilder::new().cpus(2).user_priority(123));
     let t7 = rt.new_task(&TaskBuilder::new().cpus(123).user_priority(123));
-    let t8 = rt.new_task(&TaskBuilder::new().cpus(2).user_priority(123));
-    let t9 = rt.new_task(&TaskBuilder::new().cpus(2).user_priority(123));
+    let _t8 = rt.new_task(&TaskBuilder::new().cpus(2).user_priority(123));
+    let _t9 = rt.new_task(&TaskBuilder::new().cpus(2).user_priority(123));
 
     // Subitted tasks:
     // 1 cpus: 123 123 20 20 5
@@ -91,21 +90,21 @@ fn test_task_grouping_blocker() {
 fn test_task_group_saturation() {
     let mut rt = TestEnv::new();
     rt.new_workers_cpus(&[5, 5, 5]);
-    let t1 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(2));
-    let t2 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(2));
-    let t3 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(4));
-    let t4 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(4));
-    let t5 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(6));
-    let t6 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(6));
+    let _t1 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(2));
+    let _t2 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(2));
+    let _t3 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(4));
+    let _t4 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(4));
+    let _t5 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(6));
+    let _t6 = rt.new_task(&TaskBuilder::new().cpus(4).user_priority(6));
     let now = std::time::Instant::now();
     let a = create_task_batches(rt.core(), now, None);
     assert_eq!(a.len(), 1);
     assert_eq!(a[0].size, 3);
     assert!(a[0].limit_reached);
     assert!(a[0].cuts.is_empty());
 
-    let t10 = rt.new_task(&TaskBuilder::new().cpus(1).user_priority(5));
-    let t11 = rt.new_task(&TaskBuilder::new().cpus(1).user_priority(0));
+    let _t10 = rt.new_task(&TaskBuilder::new().cpus(1).user_priority(5));
+    let _t11 = rt.new_task(&TaskBuilder::new().cpus(1).user_priority(0));
 
     let a = create_task_batches(rt.core(), now, None);
     assert_eq!(a.len(), 2);
@@ -399,7 +398,7 @@ fn test_priority_switching() {
         rt.new_tasks(5, &ta.clone().user_priority(4));
         rt.new_tasks(1, &tb.clone().user_priority(3));
         rt.schedule();
-        let mut counts = assigned_counts(&mut rt);
+        let counts = assigned_counts(&mut rt);
         assert_eq!(counts[0], count_a);
         assert_eq!(counts[1], count_b);
     }
@@ -606,7 +605,7 @@ fn test_schedule_reservation4() {
 #[test]
 fn test_schedule_reservation5() {
     let mut c = TestCase::new();
-    let ts = c.pc_tasks(&[(4, 3), (3, 3), (3, 3), (2, 1), (2, 1)]);
+    let _ts = c.pc_tasks(&[(4, 3), (3, 3), (3, 3), (2, 1), (2, 1)]);
     c.w(&WorkerBuilder::new(3))
         .running_c(2)
         .expect_request(1, &TaskBuilder::new());
@@ -651,7 +650,7 @@ fn test_schedule_multiple_resources1() {
     c.check();
 
     let mut c = create();
-    let t1 = c.t(&tb1_2);
+    let _t1 = c.t(&tb1_2);
     c.w(&w4_1).expect_tasks(&[]);
     c.check();
 
diff --git a/crates/tako/src/internal/tests/utils/env.rs b/crates/tako/src/internal/tests/utils/env.rs
@@ -3,14 +3,12 @@ use crate::gateway::LostWorkerReason;
 use crate::internal::common::Map;
 use crate::internal::common::index::ItemId;
 use crate::internal::common::resources::ResourceId;
-use crate::internal::common::utils::format_comma_delimited;
 use crate::internal::messages::common::TaskFailInfo;
 use crate::internal::messages::worker::{
     TaskRunningMsg, ToWorkerMessage, WorkerOverview, WorkerTaskUpdate,
 };
 use crate::internal::scheduler::{
-    SchedulerConfig, TaskBatch, WorkerTaskMapping, create_task_batches, create_task_mapping,
-    run_scheduling, run_scheduling_inner, run_scheduling_solver,
+    SchedulerConfig, WorkerTaskMapping, create_task_batches, create_task_mapping, run_scheduling_inner, run_scheduling_solver,
 };
 use crate::internal::server::comm::Comm;
 use crate::internal::server::core::{Core, CoreSplitMut};
@@ -21,9 +19,8 @@ use crate::internal::server::worker::Worker;
 use crate::internal::tests::utils;
 use crate::internal::tests::utils::task::TaskBuilder;
 use crate::internal::transfer::auth::{deserialize, serialize};
-use crate::resources::{ResourceAmount, ResourceUnits};
+use crate::resources::ResourceUnits;
 use crate::task::SerializedTaskContext;
-use crate::tests::utils::task::task_running_msg;
 use crate::tests::utils::worker::WorkerBuilder;
 use crate::worker::WorkerConfiguration;
 use crate::{InstanceId, JobId, JobTaskId, ResourceVariantId, Set, TaskId, WorkerId};
diff --git a/crates/tako/src/internal/tests/utils/scheduler.rs b/crates/tako/src/internal/tests/utils/scheduler.rs
@@ -1,11 +1,9 @@
-use crate::gateway::ResourceRequest;
-use crate::internal::common::resources::ResourceVec;
-use crate::internal::scheduler::{PriorityCut, TaskBatch, WorkerTaskMapping, create_task_batches};
-use crate::resources::{ResourceAmount, ResourceRqId, ResourceRqMap};
+use crate::internal::scheduler::WorkerTaskMapping;
+use crate::resources::ResourceRqId;
 use crate::tests::utils::env::TestEnv;
 use crate::tests::utils::task::TaskBuilder;
 use crate::tests::utils::worker::WorkerBuilder;
-use crate::{Map, Priority, ResourceVariantId, Set, TaskGroup, TaskId, WorkerId, WrappedRcRefCell};
+use crate::{Map, ResourceVariantId, Set, TaskId, WorkerId, WrappedRcRefCell};
 
 type TestEnvRef = WrappedRcRefCell<TestEnv>;
 
@@ -111,7 +109,6 @@ enum ExpectWorkerState {
     Empty,
     TaskIds(Vec<(TaskId, ResourceVariantId)>),
     RequestIds(Map<(ResourceRqId, ResourceVariantId), u32>),
-    Any,
 }
 
 pub(crate) struct TestWorker {
@@ -158,11 +155,6 @@ impl TestWorker {
         self.expect_request_v(count, builder, 0)
     }
 
-    pub fn expect_anything(&mut self) -> &mut Self {
-        self.expect = ExpectWorkerState::Any;
-        self
-    }
-
     pub fn expect_request_v(
         &mut self,
         count: u32,
@@ -205,7 +197,6 @@ impl TestWorker {
                     );
                 }
             }
-            ExpectWorkerState::Any => { /* Do not check anything */ }
         }
     }
 
diff --git a/crates/tako/src/internal/tests/utils/task.rs b/crates/tako/src/internal/tests/utils/task.rs
@@ -1,6 +1,5 @@
 use super::resources::ResBuilder;
 use crate::gateway::CrashLimit;
-use crate::internal::common::resources::map::GlobalResourceMapping;
 use crate::internal::common::resources::{
     NumOfNodes, ResourceAmount, ResourceId, ResourceRequestVariants,
 };
@@ -10,13 +9,12 @@ use crate::internal::messages::worker::{
 use crate::internal::server::core::Core;
 use crate::internal::server::reactor::get_or_create_raw_resource_rq_id;
 use crate::internal::server::task::{Task, TaskConfiguration};
-use crate::resources::{ResourceIdMap, ResourceRequest, ResourceRqId, ResourceRqMap};
+use crate::resources::{ResourceRequest, ResourceRqId, ResourceRqMap};
 use crate::tests::utils::env::TestComm;
 use crate::{Priority, ResourceVariantId, Set, TaskId, UserPriority};
 use smallvec::SmallVec;
 use std::rc::Rc;
 use std::time::Duration;
-use thin_vec::ThinVec;
 
 #[derive(Clone)]
 pub struct TaskBuilder {
diff --git a/crates/tako/src/internal/tests/utils/wenv.rs b/crates/tako/src/internal/tests/utils/wenv.rs
@@ -1,12 +1,10 @@
 use crate::internal::messages::worker::ComputeTasksMsg;
 use crate::internal::worker::comm::WorkerComm;
-use crate::internal::worker::state::{WorkerState, WorkerStateRef};
+use crate::internal::worker::state::WorkerStateRef;
 use crate::launcher::{StopReason, TaskBuildContext, TaskLaunchData, TaskLauncher, TaskResult};
 use crate::resources::{ResourceIdMap, ResourceRqMap};
-use crate::tests::utils::env::TestComm;
 use crate::tests::utils::task::TaskBuilder;
 use crate::tests::utils::worker::WorkerBuilder;
-use crate::tests::utils::worker_comm::TestWorkerComm;
 use crate::{ResourceVariantId, TaskId, WorkerId};
 use tokio::sync::oneshot::Receiver;
 
diff --git a/crates/tako/src/internal/tests/utils/worker.rs b/crates/tako/src/internal/tests/utils/worker.rs
@@ -36,7 +36,7 @@ impl WorkerBuilder {
         self
     }
 
-    pub fn time_limit_s(mut self, duration: u64) -> Self {
+    pub fn time_limit_s(self, duration: u64) -> Self {
         self.time_limit(Duration::from_secs(duration))
     }
 
diff --git a/crates/tako/src/internal/worker/mod.rs b/crates/tako/src/internal/worker/mod.rs
@@ -13,5 +13,3 @@ pub(crate) mod localcomm;
 
 pub mod localclient;
 pub mod notifications;
-#[cfg(test)]
-mod test_util;
diff --git a/crates/tako/src/internal/worker/resources/pool.rs b/crates/tako/src/internal/worker/resources/pool.rs
@@ -35,11 +35,6 @@ impl GroupsResourcePool {
                 )
             })
     }
-
-    #[cfg(test)]
-    pub fn n_groups(&self) -> usize {
-        self.indices.len()
-    }
 }
 
 #[derive(Debug)]
@@ -137,14 +132,6 @@ impl ResourcePool {
         }
     }
 
-    #[cfg(test)]
-    pub fn n_groups(&self) -> usize {
-        match self {
-            ResourcePool::Empty | ResourcePool::Indices(..) | ResourcePool::Sum(..) => 1,
-            ResourcePool::Groups(pool) => pool.n_groups(),
-        }
-    }
-
     pub(crate) fn concise_state(&self) -> ConciseResourceState {
         let free = match self {
             ResourcePool::Empty => smallvec![],
diff --git a/crates/tako/src/internal/worker/resources/test_allocator.rs b/crates/tako/src/internal/worker/resources/test_allocator.rs
@@ -1,19 +1,15 @@
 use crate::internal::common::resources::descriptor::{ResourceDescriptor, ResourceDescriptorKind};
-use crate::internal::common::resources::{Allocation, ResourceId, ResourceRequestVariants};
+use crate::internal::common::resources::{Allocation, ResourceId};
 use crate::internal::tests::utils::resources::{ResBuilder, cpus_compact};
 use crate::internal::tests::utils::shared::res_allocator_from_descriptor;
 use crate::internal::tests::utils::sorted_vec;
-use crate::internal::worker::resources::allocator::{AllocatorStaticInfo, ResourceAllocator};
+use crate::internal::worker::resources::allocator::ResourceAllocator;
 use crate::internal::worker::resources::concise::{ConciseFreeResources, ConciseResourceState};
-use crate::internal::worker::resources::pool::ResourcePool;
 use crate::resources::{
     AllocationRequest, ResourceAmount, ResourceDescriptorCoupling, ResourceDescriptorItem,
     ResourceIndex, ResourceUnits,
 };
-use std::cell::RefCell;
 
-use std::rc::Rc;
-use std::time::Duration;
 
 impl ResourceAllocator {
     pub fn get_sockets(&self, allocation: &Allocation, idx: u32) -> Vec<usize> {
diff --git a/crates/tako/src/internal/worker/test_util.rs b/crates/tako/src/internal/worker/test_util.rs
