Skip to main content

wlan_power_manager_testing/
testing.rs

1// Copyright 2026 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use anyhow::Error;
6use async_trait::async_trait;
7use fidl_fuchsia_power_system as fsystem;
8use fuchsia_sync::Mutex;
9use std::sync::Arc;
10use wlan_power_manager::{PowerManager, WakeLease};
11
12pub struct TestPowerManager {
13    pub calls: Arc<Mutex<Vec<String>>>,
14    pub active_leases: Arc<Mutex<Vec<(String, fsystem::LeaseToken)>>>,
15}
16
17impl TestPowerManager {
18    pub fn new() -> Self {
19        Self { calls: Arc::new(Mutex::new(vec![])), active_leases: Arc::new(Mutex::new(vec![])) }
20    }
21
22    pub fn is_lease_dropped(&self, name: &str) -> bool {
23        let leases = self.active_leases.lock();
24        if let Some((_, token)) = leases.iter().rev().find(|(n, _)| n == name) {
25            #[allow(clippy::match_like_matches_macro)]
26            match token
27                .wait_one(zx::Signals::EVENTPAIR_PEER_CLOSED, zx::MonotonicInstant::INFINITE_PAST)
28            {
29                zx::WaitResult::TimedOut(_) => false,
30                _ => true,
31            }
32        } else {
33            true
34        }
35    }
36}
37
38#[async_trait]
39impl PowerManager for TestPowerManager {
40    async fn take_wake_lease(&self, name: &str) -> Option<WakeLease> {
41        self.calls.lock().push(name.to_string());
42        let (local_token, token) = fsystem::LeaseToken::create();
43        self.active_leases.lock().push((name.to_string(), local_token));
44        Some(WakeLease::from_token_for_test(token))
45    }
46
47    async fn power_element_lease(
48        &self,
49        lease_name: &str,
50        _dependency_token: fidl_fuchsia_power_broker::DependencyToken,
51        _dependency_level: u8,
52    ) -> Result<fidl_fuchsia_power_broker::LeaseToken, Error> {
53        self.calls.lock().push(lease_name.to_string());
54        let (local_token, remote_token) = zx::EventPair::create();
55        self.active_leases.lock().push((lease_name.to_string(), remote_token));
56        Ok(local_token)
57    }
58
59    async fn register_suspend_blocker(
60        &self,
61        _suspend_blocker: fidl::endpoints::ClientEnd<fsystem::SuspendBlockerMarker>,
62        name: &str,
63    ) -> Result<WakeLease, Error> {
64        self.calls.lock().push(name.to_string());
65        let (local_token, token) = fsystem::LeaseToken::create();
66        self.active_leases.lock().push((name.to_string(), local_token));
67        Ok(WakeLease::from_token_for_test(token))
68    }
69}