// Copyright 2021 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.

mod connector;
mod suite_definition;

use crate::connector::RunConnector;
use crate::suite_definition::TestParamsOptions;
use anyhow::{anyhow, format_err, Context, Result};
use async_trait::async_trait;
use either::Either;
use errors::{ffx_bail, ffx_bail_with_code, ffx_error, ffx_error_with_code, FfxError};
use ffx_test_args::{
    EarlyBootProfileCommand, ListCommand, RunCommand, TestCommand, TestSubCommand,
};
use fho::{FfxMain, FfxTool, SimpleWriter};
use fidl::endpoints::create_proxy;
use futures::FutureExt;
use lazy_static::lazy_static;
use run_test_suite_lib::output::Reporter;
use signal_hook::consts::signal::{SIGINT, SIGTERM};
use signal_hook::iterator::Signals;
use std::fmt::Debug;
use std::io::{stdout, Write};
use {
    fidl_fuchsia_developer_remotecontrol as fremotecontrol,
    fidl_fuchsia_test_manager as ftest_manager,
};

lazy_static! {
    /// Error code returned if connecting to Test Manager fails.
    pub static ref SETUP_FAILED_CODE: i32 = -fidl::Status::UNAVAILABLE.into_raw();
    /// Error code returned if tests time out.
    pub static ref TIMED_OUT_CODE: i32 = -fidl::Status::TIMED_OUT.into_raw();
}

/// Max number of test suites to run using a single RunBuilder connection.
/// Since we need to make n SuiteController channels when running tests on a
/// single RunBuilder channel, this max limits the number of channels that need
/// to be opened before any tests are run, allowing tests to start running faster.
/// It also limits the maximum resources that overnet needs to handle at once.
/// This isn't set to 1 as (1 RunBuilder connection) = (1 set of debug data). Since
/// pulling debug data off device is expensive we also want to limit the number of
/// times this occurs.
const SUITE_BATCH_SIZE: usize = 100;

#[derive(FfxTool)]
pub struct TestTool {
    #[command]
    cmd: TestCommand,
    rcs: fho::Deferred<fremotecontrol::RemoteControlProxy>,
}

fho::embedded_plugin!(TestTool);

#[async_trait(?Send)]
impl FfxMain for TestTool {
    type Writer = SimpleWriter;

    // TODO(https://fxbug.dev/42078544): use Writer when it becomes possible.
    async fn main(self, _writer: Self::Writer) -> fho::Result<()> {
        let writer = Box::new(stdout());
        let remote_control =
            self.rcs.await.map_err(|e| ffx_error_with_code!(*SETUP_FAILED_CODE, "{:?}", e))?;
        match self.cmd.subcommand {
            TestSubCommand::Run(run) => run_test(remote_control, writer, run).await?,
            TestSubCommand::List(list) => {
                get_tests(&remote_control, writer, list).await?;
            }
            TestSubCommand::EarlyBootProfile(cmd) => {
                early_boot_profile(remote_control, writer, cmd).await?;
            }
        }
        Ok(())
    }
}

struct Experiment {
    name: &'static str,
    enabled: bool,
}

struct Experiments {
    json_input: Experiment,
    parallel_execution: Experiment,
}

impl Experiments {
    async fn get_experiment(experiment_name: &'static str) -> Experiment {
        Experiment {
            name: experiment_name,
            enabled: match ffx_config::get(experiment_name).await {
                Ok(enabled) => enabled,
                Err(_) => false,
            },
        }
    }

    async fn from_env() -> Self {
        Self {
            json_input: Self::get_experiment("test.experimental_json_input").await,
            parallel_execution: Self::get_experiment("test.enable_experimental_parallel_execution")
                .await,
        }
    }
}

async fn early_boot_profile<W: 'static + Write + Send + Sync>(
    remote_control: fremotecontrol::RemoteControlProxy,
    mut writer: W,
    cmd: EarlyBootProfileCommand,
) -> Result<()> {
    let early_boot_profile_proxy = testing_lib::connect_to_early_boot_profile(&remote_control)
        .await
        .map_err(|e| ffx_error_with_code!(*SETUP_FAILED_CODE, "{:?}", e))?;

    let (client, iterator) = fidl::endpoints::create_endpoints();
    early_boot_profile_proxy
        .register_watcher(iterator)
        .map_err(|e| ffx_error_with_code!(*SETUP_FAILED_CODE, "{:?}", e))?;

    let reporter = run_test_suite_lib::output::DirectoryReporter::new(
        cmd.output_directory,
        run_test_suite_lib::output::SchemaVersion::V1,
    )?;

    match reporter.new_directory_artifact(
        &run_test_suite_lib::output::EntityId::TestRun,
        &run_test_suite_lib::output::DirectoryArtifactType::Debug,
        None,
    ) {
        Ok(o) => run_test_suite_lib::copy_debug_data(client.into_proxy()?, o).await,
        Err(e) => {
            writeln!(writer, "Cannot create output directory: {}", e)?;
            return Err(e.into());
        }
    };
    // save summary
    reporter.entity_finished(&run_test_suite_lib::output::EntityId::TestRun)?;

    Ok(())
}

async fn run_test<W: 'static + Write + Send + Sync>(
    remote_control: fremotecontrol::RemoteControlProxy,
    mut writer: W,
    cmd: RunCommand,
) -> Result<()> {
    let experiments = Experiments::from_env().await;

    let min_log_severity = cmd.min_severity_logs.clone();
    let hermetic_test = cmd.realm.is_none();

    let output_directory = match (cmd.disable_output_directory, &cmd.output_directory) {
        (true, maybe_dir) => {
            writeln!(
                writer,
                "WARN: --disable-output-directory is now a no-op and will soon be \
                removed, please remove it from your invocation."
            )?;
            maybe_dir.clone().map(Into::into)
        }
        (false, Some(directory)) => Some(directory.clone().into()), // an override directory is specified.
        (false, None) => None,
    };
    let output_directory_options = output_directory
        .map(|root_path| run_test_suite_lib::DirectoryReporterOptions { root_path });
    let reporter =
        run_test_suite_lib::create_reporter(cmd.filter_ansi, output_directory_options, writer)?;

    let run_params = run_test_suite_lib::RunParams {
        timeout_behavior: match cmd.continue_on_timeout {
            false => run_test_suite_lib::TimeoutBehavior::TerminateRemaining,
            true => run_test_suite_lib::TimeoutBehavior::Continue,
        },
        timeout_grace_seconds: ffx_config::get::<u64, _>("test.timeout_grace_seconds").await?
            as u32,
        stop_after_failures: match cmd.stop_after_failures.map(std::num::NonZeroU32::new) {
            None => None,
            Some(None) => ffx_bail!("--stop-after-failures should be greater than zero."),
            Some(Some(stop_after)) => Some(stop_after),
        },
        experimental_parallel_execution: match (
            cmd.experimental_parallel_execution,
            experiments.parallel_execution.enabled,
        ) {
            (None, _) => None,
            (Some(max_parallel_suites), true) => Some(max_parallel_suites),
            (_, false) => ffx_bail!(
              "Parallel test suite execution is experimental and is subject to breaking changes. \
              To enable parallel test suite execution, run: \n \
              'ffx config set {} true'",
              experiments.parallel_execution.name
            ),
        },
        accumulate_debug_data: false, // ffx never accumulates.
        log_protocol: None,
        min_severity_logs: min_log_severity,
        show_full_moniker: cmd.show_full_moniker_in_logs,
    };

    let test_definitions =
        test_params_from_args(&remote_control, cmd, experiments.json_input.enabled).await?;

    let (cancel_sender, cancel_receiver) = futures::channel::oneshot::channel::<()>();
    let mut signals = Signals::new(&[SIGINT, SIGTERM]).unwrap();
    // signals.forever() is blocking, so we need to spawn a thread rather than use async.
    let _signal_handle_thread = std::thread::spawn(move || {
        if let Some(signal) = signals.forever().next() {
            match signal {
                SIGINT | SIGTERM => {
                    let _ = cancel_sender.send(());
                }
                _ => unreachable!(),
            }
        }
    });

    let start_time = std::time::Instant::now();
    let outcome = run_test_suite_lib::run_tests_and_get_outcome(
        RunConnector::new(remote_control, SUITE_BATCH_SIZE),
        test_definitions,
        run_params,
        reporter,
        cancel_receiver.map(|_| ()),
    )
    .await;
    let show_realm_warning = outcome == run_test_suite_lib::Outcome::Timedout
        || outcome == run_test_suite_lib::Outcome::Failed
        || outcome == run_test_suite_lib::Outcome::DidNotFinish;
    tracing::info!("ffx test duration: {:?}", start_time.elapsed().as_secs_f32());
    if hermetic_test && show_realm_warning {
        println!(
            "The test was executed in the hermetic realm. If your test depends on system \
capabilities, pass in correct realm. See https://fuchsia.dev/go/components/non-hermetic-tests"
        );
    }
    match outcome {
        run_test_suite_lib::Outcome::Passed => Ok(()),
        run_test_suite_lib::Outcome::Timedout => {
            ffx_bail_with_code!(*TIMED_OUT_CODE, "Tests timed out.",)
        }
        run_test_suite_lib::Outcome::Failed | run_test_suite_lib::Outcome::DidNotFinish => {
            ffx_bail!("Tests failed.")
        }
        run_test_suite_lib::Outcome::Cancelled => ffx_bail!("Tests cancelled."),
        run_test_suite_lib::Outcome::Inconclusive => ffx_bail!("Inconclusive test result."),
        run_test_suite_lib::Outcome::Error { origin } => match &*origin {
            run_test_suite_lib::RunTestSuiteError::Connection(conn_err) => {
                ffx_bail_with_code!(*SETUP_FAILED_CODE, "{:?}", conn_err)
            }
            run_test_suite_lib::RunTestSuiteError::Launch(launch_err) => match launch_err {
                ftest_manager::LaunchError::ResourceUnavailable => {
                    ffx_bail!("There were insufficient resources to launch the test.")
                }
                ftest_manager::LaunchError::InstanceCannotResolve => {
                    ffx_bail!("Cannot resolve test URL.")
                }
                ftest_manager::LaunchError::InvalidArgs => {
                    ffx_bail!("One or more invalid arguments passed.")
                }
                ftest_manager::LaunchError::FailedToConnectToTestSuite => {
                    ffx_bail!("Failed to connect to test suite.")
                }
                ftest_manager::LaunchError::CaseEnumeration => {
                    ffx_bail!("Failed to enumerate tests.")
                }
                ftest_manager::LaunchError::InternalError => {
                    ffx_bail!("An internal error occurred. Please check logs and report bug.")
                }
                ftest_manager::LaunchError::NoMatchingCases => {
                    ffx_bail!("No test cases match specified test filters.")
                }
                ftest_manager::LaunchError::InvalidManifest => {
                    ffx_bail!("Test manifest is invalid.")
                }
                other => ffx_bail!("Launch error: {:?}.", other),
            },
            other if other.is_internal_error() => {
                Err(anyhow!("There was an internal error running tests: {:?}", other))
            }
            other => ffx_bail!("There was an error running tests: {:?}", other),
        },
    }
}

/// Generate TestParams from |cmd|.
/// |stdin_handle_fn| is a function that generates a handle to stdin and is a parameter to enable
/// testing.
async fn test_params_from_args(
    remote_control: &fremotecontrol::RemoteControlProxy,
    cmd: RunCommand,
    json_input_experiment_enabled: bool,
) -> Result<impl ExactSizeIterator<Item = run_test_suite_lib::TestParams> + Debug, FfxError> {
    let lifecycle_controller = ffx_component::rcs::connect_to_lifecycle_controller(&remote_control)
        .await
        .map_err(|e| ffx_error!("Parsing realm: Cannot connect to lifecycle controller: {}", e))?;
    let realm_query = ffx_component::rcs::connect_to_realm_query(&remote_control)
        .await
        .map_err(|e| ffx_error!("Parsing realm: Cannot connect to realm query: {}", e))?;
    match &cmd.test_file {
        Some(_) if !json_input_experiment_enabled => {
            return Err(ffx_error!(
                "The --test-file option is experimental, and the input format is \
                subject to breaking changes. To enable using --test-file, run \
                'ffx config set test.experimental_json_input true'"
            ))
        }
        Some(filename) => {
            if !cmd.test_args.is_empty() {
                return Err(ffx_error!("Tests may not be specified in both args and by file"));
            } else {
                let file = std::fs::File::open(filename)
                    .map_err(|e| ffx_error!("Failed to open file {}: {:?}", filename, e))?;
                suite_definition::test_params_from_reader(
                    file,
                    &lifecycle_controller,
                    &realm_query,
                    TestParamsOptions { ignore_test_without_known_execution: false },
                )
                .await
                .map_err(|e| ffx_error!("Failed to read test definitions: {:?}", e))
            }
        }
        .map(|file_params| Either::Left(file_params.into_iter())),
        None => {
            let mut test_args_iter = cmd.test_args.iter();
            let (test_url, test_args) = match test_args_iter.next() {
                None => return Err(ffx_error!("No tests specified!")),
                Some(test_url) => {
                    (test_url.clone(), test_args_iter.map(String::clone).collect::<Vec<_>>())
                }
            };

            let mut provided_realm = None;
            if let Some(realm_str) = &cmd.realm {
                provided_realm = Some(
                    run_test_suite_lib::parse_provided_realm(
                        &lifecycle_controller,
                        &realm_query,
                        &realm_str,
                    )
                    .await
                    .map_err(|e| ffx_error!("Error parsing realm '{}': {}", realm_str, e))?,
                );
            }

            let test_params = run_test_suite_lib::TestParams {
                test_url,
                realm: provided_realm.into(),
                timeout_seconds: cmd.timeout.and_then(std::num::NonZeroU32::new),
                test_filters: if cmd.test_filter.len() == 0 { None } else { Some(cmd.test_filter) },
                max_severity_logs: cmd.max_severity_logs,
                min_severity_logs: cmd.min_severity_logs,
                also_run_disabled_tests: cmd.run_disabled,
                parallel: cmd.parallel,
                test_args,
                tags: vec![],
                break_on_failure: cmd.break_on_failure,
            };

            let count = cmd.count.unwrap_or(1);
            let count = std::num::NonZeroU32::new(count)
                .ok_or_else(|| ffx_error!("--count should be greater than zero."))?;
            let repeated = (0..count.get()).map(move |_: u32| test_params.clone());
            Ok(repeated)
        }
        .map(Either::Right),
    }
}

async fn get_tests<W: Write>(
    remote_control: &fremotecontrol::RemoteControlProxy,
    mut write: W,
    cmd: ListCommand,
) -> Result<()> {
    let query_proxy = testing_lib::connect_to_query(&remote_control)
        .await
        .map_err(|e| ffx_error_with_code!(*SETUP_FAILED_CODE, "{:?}", e))?;
    let writer = &mut write;
    let (iterator_proxy, iterator) = create_proxy().unwrap();

    tracing::info!("launching test suite {}", cmd.test_url);

    let mut provided_realm = None;
    if let Some(realm_str) = &cmd.realm {
        let lifecycle_controller =
            ffx_component::rcs::connect_to_lifecycle_controller(&remote_control).await.map_err(
                |e| ffx_error!("Parsing realm: Cannot connect to lifecycle controller: {}", e),
            )?;

        let realm_query = ffx_component::rcs::connect_to_realm_query(&remote_control)
            .await
            .map_err(|e| ffx_error!("Parsing realm: Cannot connect to realm query: {}", e))?;

        provided_realm = Some(
            run_test_suite_lib::parse_provided_realm(
                &lifecycle_controller,
                &realm_query,
                &realm_str,
            )
            .await
            .map_err(|e| ffx_error!("Error parsing realm '{}': {}", realm_str, e))?,
        );
    }

    let fut_response = match provided_realm {
        Some(realm) => {
            let offers = realm.offers();
            query_proxy.enumerate_in_realm(
                &cmd.test_url,
                realm
                    .get_realm_client()
                    .map_err(|e| ffx_error!("Cannot connect to realm client: {}", e))?,
                offers.as_slice(),
                realm.collection(),
                iterator,
            )
        }
        None => query_proxy.enumerate(&cmd.test_url, iterator),
    };

    fut_response
        .await
        .context("enumeration failed")?
        .map_err(|e| format_err!("error launching test: {:?}", e))?;

    loop {
        let cases = iterator_proxy.get_next().await?;
        if cases.is_empty() {
            return Ok(());
        }
        for case in cases {
            match case.name {
                Some(n) => writeln!(writer, "{}", n)?,
                None => writeln!(writer, "<No name>")?,
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use fidl::endpoints::{create_proxy_and_stream, ProtocolMarker, RequestStream, ServerEnd};
    use fidl_fuchsia_sys2 as fsys;
    use ftest_manager::{
        DebugData, DebugDataIteratorMarker, EarlyBootProfileMarker, EarlyBootProfileRequestStream,
    };
    use futures::prelude::*;
    use lazy_static::lazy_static;
    use std::io::Read;
    use std::num::NonZeroU32;
    use std::sync::Arc;
    use test_list::TestTag;

    const VALID_INPUT_FILENAME: &str = "valid_defs.json";
    const INVALID_INPUT_FILENAME: &str = "invalid_defs.json";

    lazy_static! {
        static ref VALID_INPUT_FORMAT: String = serde_json::to_string(&serde_json::json!({
          "schema_id": "experimental",
          "data": [
            {
                "name": "{}-test-1",
                "labels": ["{}-label"],
                "execution": {
                    "type": "fuchsia_component",
                    "component_url": "{}-test-url-1",
                },
                "tags": [],
            },
            {
                "name": "{}-test-2",
                "labels": ["{}-label"],
                "execution": {
                    "type": "fuchsia_component",
                    "component_url": "{}-test-url-2",
                    "timeout_seconds": 60,
                },
                "tags": [],
            },
            {
                "name": "{}-test-3",
                "labels": ["{}-label"],
                "execution": {
                    "type": "fuchsia_component",
                    "component_url": "{}-test-url-3",
                    "test_args": ["--flag"],
                    "test_filters": ["Unit"],
                    "also_run_disabled_tests": true,
                    "parallel": 4,
                    "max_severity_logs": "INFO",
                },
                "tags": [{
                    "key": "hermetic",
                    "value": "true",
                }],
            }
        ]}))
        .expect("serialize json");
        static ref VALID_FILE_INPUT: Vec<u8> =
            VALID_INPUT_FORMAT.replace("{}", "file").into_bytes();
        static ref INVALID_INPUT: Vec<u8> = vec![1u8; 64];
    }

    struct FakeRemoteControllerProvider {
        controller: Arc<fremotecontrol::RemoteControlProxy>,
        _task: fuchsia_async::Task<()>,
    }

    impl FakeRemoteControllerProvider {
        fn new() -> FakeRemoteControllerProvider {
            let (remote_control, mut stream) =
                create_proxy_and_stream::<fremotecontrol::RemoteControlMarker>().unwrap();
            let _task = fuchsia_async::Task::spawn(async move {
                while let Some(request) = stream.try_next().await.unwrap() {
                    // store channels so that they do not die.
                    let mut server_channels = vec![];
                    match request {
                        fremotecontrol::RemoteControlRequest::OpenCapability {
                            moniker,
                            capability_set,
                            capability_name,
                            server_channel,
                            flags: _,
                            responder,
                        } => {
                            assert_eq!(moniker, "core/remote-control");
                            assert_eq!(capability_set, fsys::OpenDirType::NamespaceDir);
                            assert!(
                                capability_name == "svc/fuchsia.sys2.RealmQuery.root"
                                    || capability_name
                                        == "svc/fuchsia.sys2.LifecycleController.root"
                            );
                            server_channels.push(server_channel);
                            responder.send(Ok(())).expect("error sending EchoString response");
                        }
                        other => {
                            unreachable!("Got unexpected request: {other:?}");
                        }
                    }
                }
            });
            FakeRemoteControllerProvider { controller: remote_control.into(), _task }
        }

        fn remote_controller(&self) -> &fremotecontrol::RemoteControlProxy {
            self.controller.as_ref()
        }
    }

    #[fuchsia::test]
    async fn test_get_test_params() {
        let dir = tempfile::tempdir().expect("Create temp dir");
        std::fs::write(dir.path().join("test_defs.json"), &*VALID_FILE_INPUT).expect("write file");

        let cases = vec![
            (
                RunCommand {
                    timeout: None,
                    test_args: vec!["my-test-url".to_string()],
                    test_file: None,
                    test_filter: vec![],
                    realm: None,
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: vec![],
                    show_full_moniker_in_logs: false,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                    experimental_parallel_execution: None,
                    break_on_failure: false,
                },
                vec![run_test_suite_lib::TestParams {
                    test_url: "my-test-url".to_string(),
                    realm: None.into(),
                    timeout_seconds: None,
                    test_filters: None,
                    also_run_disabled_tests: false,
                    parallel: None,
                    test_args: vec![],
                    max_severity_logs: None,
                    min_severity_logs: vec![],
                    tags: vec![],
                    break_on_failure: false,
                }],
            ),
            (
                RunCommand {
                    timeout: None,
                    test_args: vec!["my-test-url".to_string()],
                    test_file: None,
                    test_filter: vec![],
                    realm: None,
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: Some(10),
                    min_severity_logs: vec![],
                    show_full_moniker_in_logs: false,
                    max_severity_logs: Some(diagnostics_data::Severity::Warn),
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                    experimental_parallel_execution: None,
                    break_on_failure: false,
                },
                vec![
                    run_test_suite_lib::TestParams {
                        test_url: "my-test-url".to_string(),
                        realm: None.into(),
                        timeout_seconds: None,
                        test_filters: None,
                        also_run_disabled_tests: false,
                        max_severity_logs: Some(diagnostics_data::Severity::Warn),
                        min_severity_logs: vec![],
                        parallel: None,
                        test_args: vec![],
                        tags: vec![],
                        break_on_failure: false,
                    };
                    10
                ],
            ),
            (
                RunCommand {
                    timeout: Some(10),
                    test_args: vec!["my-test-url".to_string(), "--".to_string(), "arg".to_string()],
                    test_file: None,
                    test_filter: vec!["filter".to_string()],
                    realm: None,
                    run_disabled: true,
                    filter_ansi: false,
                    parallel: Some(20),
                    count: None,
                    show_full_moniker_in_logs: false,
                    min_severity_logs: vec![],
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                    experimental_parallel_execution: None,
                    break_on_failure: false,
                },
                vec![run_test_suite_lib::TestParams {
                    test_url: "my-test-url".to_string(),
                    realm: None.into(),
                    timeout_seconds: Some(NonZeroU32::new(10).unwrap()),
                    test_filters: Some(vec!["filter".to_string()]),
                    also_run_disabled_tests: true,
                    max_severity_logs: None,
                    min_severity_logs: vec![],
                    parallel: Some(20),
                    test_args: vec!["--".to_string(), "arg".to_string()],
                    tags: vec![],
                    break_on_failure: false,
                }],
            ),
            (
                RunCommand {
                    timeout: None,
                    test_args: vec![],
                    test_file: Some(
                        dir.path().join("test_defs.json").to_str().unwrap().to_string(),
                    ),
                    test_filter: vec![],
                    realm: None,
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: vec![],
                    show_full_moniker_in_logs: false,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                    experimental_parallel_execution: None,
                    break_on_failure: false,
                },
                vec![
                    run_test_suite_lib::TestParams {
                        test_url: "file-test-url-1".to_string(),
                        realm: None.into(),
                        timeout_seconds: None,
                        test_filters: None,
                        also_run_disabled_tests: false,
                        max_severity_logs: None,
                        min_severity_logs: vec![],
                        parallel: None,
                        test_args: vec![],
                        tags: vec![],
                        break_on_failure: false,
                    },
                    run_test_suite_lib::TestParams {
                        test_url: "file-test-url-2".to_string(),
                        realm: None.into(),
                        timeout_seconds: Some(NonZeroU32::new(60).unwrap()),
                        test_filters: None,
                        also_run_disabled_tests: false,
                        max_severity_logs: None,
                        min_severity_logs: vec![],
                        parallel: None,
                        test_args: vec![],
                        tags: vec![],
                        break_on_failure: false,
                    },
                    run_test_suite_lib::TestParams {
                        test_url: "file-test-url-3".to_string(),
                        realm: None.into(),
                        timeout_seconds: None,
                        test_filters: Some(vec!["Unit".to_string()]),
                        also_run_disabled_tests: true,
                        max_severity_logs: Some(diagnostics_data::Severity::Info),
                        min_severity_logs: vec![],
                        parallel: Some(4),
                        test_args: vec!["--flag".to_string()],
                        tags: vec![TestTag {
                            key: "hermetic".to_string(),
                            value: "true".to_string(),
                        }],
                        break_on_failure: false,
                    },
                ],
            ),
        ];
        let fake_contoller = FakeRemoteControllerProvider::new();
        for (run_command, expected_test_params) in cases.into_iter() {
            let result = test_params_from_args(
                fake_contoller.remote_controller(),
                run_command.clone(),
                true,
            )
            .await;
            assert!(
                result.is_ok(),
                "Error getting test params from {:?}: {:?}",
                run_command,
                result.unwrap_err()
            );
            assert_eq!(result.unwrap().into_iter().collect::<Vec<_>>(), expected_test_params);
        }
    }

    #[fuchsia::test]
    async fn test_get_test_params_count() {
        // Regression test for https://fxbug.dev/42062444: using an extremely
        // large test count should result in a modest memory allocation. If
        // that wasn't the case, this test would fail.
        const COUNT: u32 = u32::MAX;
        let fake_contoller = FakeRemoteControllerProvider::new();
        let params = test_params_from_args(
            fake_contoller.remote_controller(),
            RunCommand {
                test_args: vec!["my-test-url".to_string()],
                count: Some(COUNT),
                timeout: None,
                test_file: None,
                test_filter: vec![],
                realm: None,
                run_disabled: false,
                filter_ansi: false,
                parallel: None,
                min_severity_logs: vec![],
                show_full_moniker_in_logs: false,
                max_severity_logs: Some(diagnostics_data::Severity::Warn),
                output_directory: None,
                disable_output_directory: false,
                continue_on_timeout: false,
                stop_after_failures: None,
                experimental_parallel_execution: None,
                break_on_failure: false,
            },
            true,
        )
        .await
        .expect("should succeed");
        assert_eq!(params.len(), usize::try_from(COUNT).unwrap());
    }

    #[fuchsia::test]
    async fn test_get_test_params_invalid_args() {
        let dir = tempfile::tempdir().expect("Create temp dir");
        std::fs::write(dir.path().join(VALID_INPUT_FILENAME), &*VALID_FILE_INPUT)
            .expect("write file");
        std::fs::write(dir.path().join(INVALID_INPUT_FILENAME), &*INVALID_INPUT)
            .expect("write file");
        let cases = vec![
            (
                "no tests specified",
                RunCommand {
                    timeout: None,
                    test_args: vec![],
                    test_file: None,
                    test_filter: vec![],
                    realm: None,
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: vec![],
                    show_full_moniker_in_logs: false,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                    experimental_parallel_execution: None,
                    break_on_failure: false,
                },
            ),
            (
                "tests specified in both args and file",
                RunCommand {
                    timeout: None,
                    test_args: vec!["my-test".to_string()],
                    test_file: Some(
                        dir.path().join(VALID_INPUT_FILENAME).to_str().unwrap().to_string(),
                    ),
                    test_filter: vec![],
                    realm: None,
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: vec![],
                    show_full_moniker_in_logs: false,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                    experimental_parallel_execution: None,
                    break_on_failure: false,
                },
            ),
            (
                "read invalid input from file",
                RunCommand {
                    timeout: None,
                    test_args: vec![],
                    test_file: Some(
                        dir.path().join(INVALID_INPUT_FILENAME).to_str().unwrap().to_string(),
                    ),
                    test_filter: vec![],
                    realm: None,
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: vec![],
                    show_full_moniker_in_logs: false,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                    experimental_parallel_execution: None,
                    break_on_failure: false,
                },
            ),
        ];
        let fake_contoller = FakeRemoteControllerProvider::new();
        for (case_name, invalid_run_command) in cases.into_iter() {
            let result = test_params_from_args(
                fake_contoller.remote_controller(),
                invalid_run_command,
                true,
            )
            .await;
            assert!(
                result.is_err(),
                "Getting test params for case '{}' unexpectedly succeeded",
                case_name
            );
        }
    }

    async fn fake_debug_data_iterator(iterator: ServerEnd<DebugDataIteratorMarker>) {
        let mut stream = iterator.into_stream().unwrap();

        // we just need to send once sample file and not test full logic as that is tested inside the library.
        let (s1, s2) = fidl::Socket::create_stream();
        let mut debug_data = vec![DebugData {
            name: "test_file".to_string().into(),
            socket: s1.into(),
            ..Default::default()
        }];
        s2.write(&[1, 2, 3, 4, 5]).unwrap();
        while let Some(request) = stream.try_next().await.unwrap() {
            match request {
                ftest_manager::DebugDataIteratorRequest::GetNext { responder } => {
                    responder.send(debug_data.drain(..).collect()).unwrap();
                }
            }
        }
    }

    #[fuchsia::test]
    async fn test_early_boot_profile() {
        let (remote_control, mut stream) =
            create_proxy_and_stream::<fremotecontrol::RemoteControlMarker>().unwrap();
        let task = fuchsia_async::Task::spawn(async move {
            let mut once = false;
            while let Some(request) = stream.try_next().await.unwrap() {
                match request {
                    fremotecontrol::RemoteControlRequest::OpenCapability {
                        moniker,
                        capability_set,
                        capability_name,
                        server_channel,
                        flags: _,
                        responder,
                    } => {
                        assert!(!once);
                        once = true;
                        assert_eq!(moniker, "/core/test_manager");
                        assert_eq!(capability_set, fsys::OpenDirType::ExposedDir);
                        assert!(capability_name == EarlyBootProfileMarker::DEBUG_NAME);
                        responder.send(Ok(())).expect("error sending EchoString response");

                        let mut stream = EarlyBootProfileRequestStream::from_channel(
                            fidl::AsyncChannel::from_channel(server_channel),
                        );
                        while let Some(request) = stream.try_next().await.unwrap() {
                            match request {
                                ftest_manager::EarlyBootProfileRequest::RegisterWatcher {
                                    iterator,
                                    control_handle: _,
                                } => {
                                    fake_debug_data_iterator(iterator).await;
                                }
                                other => {
                                    unreachable!("Got unexpected request: {other:?}");
                                }
                            }
                        }
                    }
                    other => {
                        unreachable!("Got unexpected request: {other:?}");
                    }
                }
            }
        });
        // Create a temporary directory
        let temp_dir = tempfile::tempdir().expect("Failed to create temporary directory");
        let temp_dir_path = temp_dir.path();
        early_boot_profile(
            remote_control,
            std::io::sink(),
            EarlyBootProfileCommand { output_directory: temp_dir_path.to_path_buf() },
        )
        .await
        .unwrap();
        task.await;

        let mut found_test_file = false;
        for entry in walkdir::WalkDir::new(temp_dir_path).follow_links(false) {
            let entry = entry.unwrap();

            // Optionally, you can print other information about the entry
            if entry.file_type().is_file() {
                if entry.file_name() == "test_file" {
                    found_test_file = true;
                    let mut file_content = Vec::new();
                    let mut file = std::fs::File::open(entry.path()).expect("Failed to open file");
                    file.read_to_end(&mut file_content).expect("Failed to read file");
                    assert_eq!(file_content, [1, 2, 3, 4, 5]);
                    break;
                }
            }
        }
        assert!(found_test_file);
    }
}