src/bringup/bin/userboot/tests/multiple_svc_test.rs

// Copyright 2026 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use helper::{
    debug_data_message, init_test_logging, koid, on_each_message, peer_koid, stashed_svc,
    svc_stash, take_svc_channel,
};
use published_data::{PUBLISHER_SINK_NAME, VMO_CONTENTS};
use std::ffi::CStr;
use std::str::from_utf8;
use zx::sys::ZX_KOID_INVALID;
use zx::{Channel, EventPair, Koid, MonotonicInstant, Signals, Vmo, WaitResult};
use zx_libc::sanitizer::publish_data;

struct MultipleProcessSvcTest {
    local_svc: Channel,
    stashed_svc: Channel,
    provider_svc: Channel,
}

impl MultipleProcessSvcTest {
    fn new() -> Self {
        let svc_stash = svc_stash();
        assert!(!svc_stash.is_invalid());

        // Order matters: provider is stored first.
        let (provider_svc, stashed_svc) = stashed_svc(svc_stash);
        let provider_svc = provider_svc.expect("expected provider svc in stash");
        let local_svc = take_svc_channel();

        Self { local_svc, stashed_svc, provider_svc }
    }

    fn provider_data_matches_expectations(&self) {
        let mut found = false;
        on_each_message(&self.provider_svc, |stashed_svc| {
            let debug_msg = debug_data_message(stashed_svc);
            if debug_msg.sink != PUBLISHER_SINK_NAME {
                return true;
            }
            found = true;

            // Token must be signaled with peer closed.
            match debug_msg
                .token
                .wait_one(Signals::EVENTPAIR_PEER_CLOSED, MonotonicInstant::INFINITE_PAST)
            {
                WaitResult::Ok(observed) => {
                    assert!(observed.contains(Signals::EVENTPAIR_PEER_CLOSED));
                }
                other => {
                    panic!(
                        "expected token to be signaled with EVENTPAIR_PEER_CLOSED, got: {other:?}"
                    );
                }
            }

            // Check VMO contents.
            let mut actual_contents = [0u8; VMO_CONTENTS.len()];
            debug_msg.vmo.read(&mut actual_contents, 0).expect("failed to read VMO contents");
            assert_eq!(from_utf8(&actual_contents).expect("valid utf-8"), VMO_CONTENTS);
            false
        });
        assert!(found);
    }

    fn sanitizer_publish_data_shows_up_in_stashed_handle(&self) {
        assert!(!self.local_svc.is_invalid());
        assert!(!self.stashed_svc.is_invalid());

        let vmo = Vmo::create(124).expect("failed to create VMO");

        const DATA_SINK: &str = "some_sink_name";
        const DATA_SINK_CSTR: &CStr = c"some_sink_name";
        let vmo_koid = koid(vmo.as_handle_ref());
        let token_1: EventPair = publish_data(DATA_SINK_CSTR, vmo).into();
        assert!(!token_1.is_invalid());

        let token_koid = peer_koid(token_1.as_handle_ref());
        assert_ne!(token_koid, Koid::from_raw(ZX_KOID_INVALID));
        assert_ne!(vmo_koid, Koid::from_raw(ZX_KOID_INVALID));

        let mut found = false;
        on_each_message(&self.stashed_svc, |stashed_svc| {
            let debug_msg = debug_data_message(stashed_svc);
            if debug_msg.sink != DATA_SINK {
                return true;
            }
            found = true;

            assert_eq!(debug_msg.sink, DATA_SINK);
            assert_eq!(koid(debug_msg.vmo.as_handle_ref()), vmo_koid);
            assert_eq!(koid(debug_msg.token.as_handle_ref()), token_koid);
            false
        });
        assert!(found);
    }
}

fn main() {
    init_test_logging();
    let test = MultipleProcessSvcTest::new();
    test.provider_data_matches_expectations();
    test.sanitizer_publish_data_shows_up_in_stashed_handle();
}