garnet/bin/setui/src/tests/display_tests.rs

// Copyright 2019 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 {
    crate::agent::restore_agent,
    crate::base::SettingType,
    crate::config::base::ControllerFlag,
    crate::display::types::{DisplayInfo, LowLightMode, Theme},
    crate::handler::device_storage::testing::InMemoryStorageFactory,
    crate::tests::fakes::brightness_service::BrightnessService,
    crate::tests::fakes::service_registry::ServiceRegistry,
    crate::tests::test_failure_utils::create_test_env_with_failures,
    crate::EnvironmentBuilder,
    anyhow::format_err,
    fidl::endpoints::{ServerEnd, ServiceMarker},
    fidl::Error::ClientChannelClosed,
    fidl_fuchsia_settings::{
        DisplayMarker, DisplayProxy, DisplaySettings, Error as FidlError, IntlMarker,
        LowLightMode as FidlLowLightMode, Theme as FidlTheme, ThemeMode as FidlThemeMode,
        ThemeType as FidlThemeType,
    },
    fuchsia_async as fasync,
    fuchsia_zircon::{self as zx, Status},
    futures::future::BoxFuture,
    futures::lock::Mutex,
    futures::prelude::*,
    matches::assert_matches,
    std::sync::Arc,
};

const ENV_NAME: &str = "settings_service_display_test_environment";
const STARTING_BRIGHTNESS: f32 = 0.5;
const CHANGED_BRIGHTNESS: f32 = 0.8;
const AUTO_BRIGHTNESS_LEVEL: f32 = 0.9;

async fn setup_display_env() -> DisplayProxy {
    let env = EnvironmentBuilder::new(Arc::new(InMemoryStorageFactory::new()))
        .settings(&[SettingType::Display])
        .spawn_and_get_nested_environment(ENV_NAME)
        .await
        .unwrap();

    env.connect_to_service::<DisplayMarker>().unwrap()
}

async fn setup_brightness_display_env() -> (DisplayProxy, BrightnessService) {
    let service_registry = ServiceRegistry::create();
    let brightness_service_handle = BrightnessService::create();
    service_registry
        .lock()
        .await
        .register_service(Arc::new(Mutex::new(brightness_service_handle.clone())));

    let env = EnvironmentBuilder::new(Arc::new(InMemoryStorageFactory::new()))
        .service(Box::new(ServiceRegistry::serve(service_registry)))
        .settings(&[SettingType::Display])
        .flags(&[ControllerFlag::ExternalBrightnessControl])
        .spawn_and_get_nested_environment(ENV_NAME)
        .await
        .unwrap();

    (env.connect_to_service::<DisplayMarker>().unwrap(), brightness_service_handle)
}

// Creates an environment that will fail on a get request.
async fn create_display_test_env_with_failures(
    storage_factory: Arc<InMemoryStorageFactory>,
) -> DisplayProxy {
    create_test_env_with_failures(storage_factory, ENV_NAME, SettingType::Display)
        .await
        .connect_to_service::<DisplayMarker>()
        .unwrap()
}

// Tests that the FIDL calls for manual brightness result in appropriate
// commands sent to the service.
#[fuchsia_async::run_until_stalled(test)]
async fn test_manual_brightness_with_storage_controller() {
    let display_proxy = setup_display_env().await;

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.brightness_value, Some(STARTING_BRIGHTNESS));

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.brightness_value = Some(CHANGED_BRIGHTNESS);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.brightness_value, Some(CHANGED_BRIGHTNESS));
}

// Tests that the FIDL calls for manual brightness result in appropriate
// commands sent to the service.
#[fuchsia_async::run_until_stalled(test)]
async fn test_manual_brightness_with_brightness_controller() {
    let (display_proxy, brightness_service_handle) = setup_brightness_display_env().await;

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.brightness_value, Some(STARTING_BRIGHTNESS));

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.brightness_value = Some(CHANGED_BRIGHTNESS);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.brightness_value, Some(CHANGED_BRIGHTNESS));

    let current_brightness =
        brightness_service_handle.get_manual_brightness().lock().await.expect("get successful");
    assert_eq!(current_brightness, CHANGED_BRIGHTNESS);
}

// Tests that the FIDL calls for auto brightness result in appropriate
// commands sent to the service.
#[fuchsia_async::run_until_stalled(test)]
async fn test_auto_brightness_with_storage_controller() {
    let display_proxy = setup_display_env().await;

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.auto_brightness = Some(true);
    display_settings.adjusted_auto_brightness = Some(AUTO_BRIGHTNESS_LEVEL);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.auto_brightness, Some(true));
    assert_eq!(settings.adjusted_auto_brightness, Some(AUTO_BRIGHTNESS_LEVEL));
}

// Tests that the FIDL calls for auto brightness result in appropriate
// commands sent to the service.
#[fuchsia_async::run_until_stalled(test)]
async fn test_auto_brightness_with_brightness_controller() {
    let (display_proxy, brightness_service_handle) = setup_brightness_display_env().await;

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.auto_brightness = Some(true);
    display_settings.adjusted_auto_brightness = Some(AUTO_BRIGHTNESS_LEVEL);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.auto_brightness, Some(true));
    assert_eq!(settings.adjusted_auto_brightness, Some(AUTO_BRIGHTNESS_LEVEL));

    let auto_brightness =
        brightness_service_handle.get_auto_brightness().lock().await.expect("get successful");
    assert!(auto_brightness);
}

// Tests that the FIDL calls for light mode result in appropriate
// commands sent to the service.
#[fuchsia_async::run_until_stalled(test)]
async fn test_light_mode_with_storage_controller() {
    let display_proxy = setup_display_env().await;

    // Test that if display is enabled, it is reflected.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.low_light_mode = Some(FidlLowLightMode::Enable);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.low_light_mode, Some(FidlLowLightMode::Enable));

    // Test that if display is disabled, it is reflected.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.low_light_mode = Some(FidlLowLightMode::Disable);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.low_light_mode, Some(FidlLowLightMode::Disable));

    // Test that if display is disabled immediately, it is reflected.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.low_light_mode = Some(FidlLowLightMode::DisableImmediately);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.low_light_mode, Some(FidlLowLightMode::DisableImmediately));
}

// Tests that the FIDL calls for light mode result in appropriate
// commands sent to the service.
#[fuchsia_async::run_until_stalled(test)]
async fn test_light_mode_with_brightness_controller() {
    let (display_proxy, _) = setup_brightness_display_env().await;

    // Test that if display is enabled, it is reflected.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.low_light_mode = Some(FidlLowLightMode::Enable);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.low_light_mode, Some(FidlLowLightMode::Enable));

    // Test that if display is disabled, it is reflected.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.low_light_mode = Some(FidlLowLightMode::Disable);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.low_light_mode, Some(FidlLowLightMode::Disable));

    // Test that if display is disabled immediately, it is reflected.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.low_light_mode = Some(FidlLowLightMode::DisableImmediately);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.low_light_mode, Some(FidlLowLightMode::DisableImmediately));
}

// Tests for display theme.
#[fuchsia_async::run_until_stalled(test)]
async fn test_theme_type_light() {
    let incoming_theme =
        Some(FidlTheme { theme_type: Some(FidlThemeType::Light), ..FidlTheme::EMPTY });
    let expected_theme = incoming_theme.clone();

    let display_proxy = setup_display_env().await;

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.theme = incoming_theme;
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.theme, expected_theme);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_theme_type_light_theme_mode_empty() {
    let incoming_theme = Some(FidlTheme {
        theme_type: Some(FidlThemeType::Light),
        theme_mode: Some(FidlThemeMode::empty()),
        ..FidlTheme::EMPTY
    });
    // theme_mode of 0x00 should be replaced with theme_mode absent.
    let expected_theme =
        Some(FidlTheme { theme_type: Some(FidlThemeType::Light), ..FidlTheme::EMPTY });

    let display_proxy = setup_display_env().await;

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.theme = incoming_theme;
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.theme, expected_theme);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_no_theme_set() {
    let expected_theme = Some(FidlTheme {
        theme_type: Some(FidlThemeType::Light),
        theme_mode: Some(FidlThemeMode::Auto),
        ..FidlTheme::EMPTY
    });
    let display_proxy = setup_display_env().await;

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.theme, expected_theme);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_theme_mode_auto() {
    let incoming_theme =
        Some(FidlTheme { theme_mode: Some(FidlThemeMode::Auto), ..FidlTheme::EMPTY });
    let expected_theme = Some(FidlTheme {
        theme_type: Some(FidlThemeType::Light),
        ..incoming_theme.clone().unwrap()
    });

    let display_proxy = setup_display_env().await;

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.theme = incoming_theme;
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.theme, expected_theme);
}

// TODO(fxb/64775) Remove this test once we remove the theme type of AUTO.
#[fuchsia_async::run_until_stalled(test)]
async fn test_theme_type_auto() {
    let incoming_theme =
        Some(FidlTheme { theme_type: Some(FidlThemeType::Auto), ..FidlTheme::EMPTY });
    let expected_theme = Some(FidlTheme {
        theme_mode: Some(FidlThemeMode::Auto),
        ..incoming_theme.clone().unwrap()
    });

    let display_proxy = setup_display_env().await;

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.theme = incoming_theme;
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.theme, expected_theme);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_theme_mode_auto_and_type_light() {
    let incoming_theme = Some(FidlTheme {
        theme_mode: Some(FidlThemeMode::Auto),
        theme_type: Some(FidlThemeType::Light),
        ..FidlTheme::EMPTY
    });
    let expected_theme = incoming_theme.clone();

    let display_proxy = setup_display_env().await;

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.theme = incoming_theme;
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.theme, expected_theme);
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_theme_mode_auto_preserves_previous_type() {
    let first_incoming_theme =
        Some(FidlTheme { theme_type: Some(FidlThemeType::Light), ..FidlTheme::EMPTY });
    let second_incoming_theme =
        Some(FidlTheme { theme_mode: Some(FidlThemeMode::Auto), ..FidlTheme::EMPTY });
    let expected_theme = Some(FidlTheme {
        theme_mode: Some(FidlThemeMode::Auto),
        theme_type: Some(FidlThemeType::Light),
        ..FidlTheme::EMPTY
    });

    let display_proxy = setup_display_env().await;

    let mut first_display_settings = DisplaySettings::EMPTY;
    first_display_settings.theme = first_incoming_theme;
    display_proxy
        .set(first_display_settings)
        .await
        .expect("set completed")
        .expect("set successful");

    let mut second_display_settings = DisplaySettings::EMPTY;
    second_display_settings.theme = second_incoming_theme;
    display_proxy
        .set(second_display_settings)
        .await
        .expect("set completed")
        .expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings.theme, expected_theme);
}

// Tests that the FIDL calls for screen enabled result in appropriate
// commands sent to the service.
#[fuchsia_async::run_until_stalled(test)]
async fn test_screen_enabled_with_storage_controller() {
    let display_proxy = setup_display_env().await;
    test_screen_enabled(display_proxy).await;
}

// Tests that the FIDL calls for screen enabled result in appropriate
// commands sent to the service.
#[fuchsia_async::run_until_stalled(test)]
async fn test_screen_enabled_with_brightness_controller() {
    let (display_proxy, _) = setup_brightness_display_env().await;
    test_screen_enabled(display_proxy).await;
}

async fn test_screen_enabled(display_proxy: DisplayProxy) {
    // Test that if screen is turned off, it is reflected.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.auto_brightness = Some(false);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.screen_enabled = Some(false);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.screen_enabled, Some(false));

    // Test that if display is turned back on, the display and manual brightness are on.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.screen_enabled = Some(true);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.screen_enabled, Some(true));
    assert_eq!(settings.auto_brightness, Some(false));

    // Test that if auto brightness is turned on, the display and auto brightness are on.
    let mut display_settings = DisplaySettings::EMPTY;
    display_settings.auto_brightness = Some(true);
    display_proxy.set(display_settings).await.expect("set completed").expect("set successful");

    let settings = display_proxy.watch().await.expect("watch completed");

    assert_eq!(settings.auto_brightness, Some(true));
    assert_eq!(settings.screen_enabled, Some(true));
}

// Makes sure that settings are restored from storage when service comes online.
#[fuchsia_async::run_until_stalled(test)]
async fn test_display_restore_with_storage_controller() {
    // Ensure auto-brightness value is restored correctly.
    validate_restore_with_storage_controller(
        0.7,
        AUTO_BRIGHTNESS_LEVEL,
        true,
        true,
        LowLightMode::Enable,
        None,
    )
    .await;

    // Ensure manual-brightness value is restored correctly.
    validate_restore_with_storage_controller(
        0.9,
        AUTO_BRIGHTNESS_LEVEL,
        false,
        true,
        LowLightMode::Disable,
        None,
    )
    .await;
}

async fn validate_restore_with_storage_controller(
    manual_brightness: f32,
    auto_brightness_value: f32,
    auto_brightness: bool,
    screen_enabled: bool,
    low_light_mode: LowLightMode,
    theme: Option<Theme>,
) {
    let service_registry = ServiceRegistry::create();
    let info = DisplayInfo {
        manual_brightness_value: manual_brightness,
        auto_brightness_value,
        auto_brightness,
        screen_enabled,
        low_light_mode,
        theme,
    };
    let storage_factory = InMemoryStorageFactory::with_initial_data(&info);

    let env = EnvironmentBuilder::new(Arc::new(storage_factory))
        .service(Box::new(ServiceRegistry::serve(service_registry)))
        .agents(&[restore_agent::blueprint::create()])
        .settings(&[SettingType::Display])
        .spawn_and_get_nested_environment(ENV_NAME)
        .await
        .ok();

    assert!(env.is_some());

    let display_proxy = env.unwrap().connect_to_service::<DisplayMarker>().unwrap();
    let settings = display_proxy.watch().await.expect("watch completed");

    if auto_brightness {
        assert_eq!(settings.auto_brightness, Some(auto_brightness));
        assert_eq!(settings.adjusted_auto_brightness, Some(auto_brightness_value));
    } else {
        assert_eq!(settings.brightness_value, Some(manual_brightness));
    }
}

// Makes sure that settings are restored from storage when service comes online.
#[fuchsia_async::run_until_stalled(test)]
async fn test_display_restore_with_brightness_controller() {
    // Ensure auto-brightness value is restored correctly.
    validate_restore_with_brightness_controller(
        0.7,
        AUTO_BRIGHTNESS_LEVEL,
        true,
        true,
        LowLightMode::Enable,
        None,
    )
    .await;

    // Ensure manual-brightness value is restored correctly.
    validate_restore_with_brightness_controller(
        0.9,
        AUTO_BRIGHTNESS_LEVEL,
        false,
        true,
        LowLightMode::Disable,
        None,
    )
    .await;
}

async fn validate_restore_with_brightness_controller(
    manual_brightness: f32,
    auto_brightness_value: f32,
    auto_brightness: bool,
    screen_enabled: bool,
    low_light_mode: LowLightMode,
    theme: Option<Theme>,
) {
    let service_registry = ServiceRegistry::create();
    let brightness_service_handle = BrightnessService::create();
    service_registry
        .lock()
        .await
        .register_service(Arc::new(Mutex::new(brightness_service_handle.clone())));
    let info = DisplayInfo {
        manual_brightness_value: manual_brightness,
        auto_brightness_value,
        auto_brightness,
        screen_enabled,
        low_light_mode,
        theme,
    };
    let storage_factory = InMemoryStorageFactory::with_initial_data(&info);

    assert!(EnvironmentBuilder::new(Arc::new(storage_factory))
        .service(Box::new(ServiceRegistry::serve(service_registry)))
        .agents(&[restore_agent::blueprint::create()])
        .settings(&[SettingType::Display])
        .flags(&[ControllerFlag::ExternalBrightnessControl])
        .spawn_and_get_nested_environment(ENV_NAME)
        .await
        .is_ok());

    if auto_brightness {
        let service_auto_brightness =
            brightness_service_handle.get_auto_brightness().lock().await.unwrap();
        assert_eq!(service_auto_brightness, auto_brightness);
    } else {
        let service_manual_brightness =
            brightness_service_handle.get_manual_brightness().lock().await.unwrap();
        assert_eq!(service_manual_brightness, manual_brightness);
    }
}

// Makes sure that a failing display stream doesn't cause a failure for a different interface.
#[fuchsia_async::run_until_stalled(test)]
async fn test_display_failure() {
    let service_gen = |service_name: &str,
                       channel: zx::Channel|
     -> BoxFuture<'static, Result<(), anyhow::Error>> {
        match service_name {
            fidl_fuchsia_ui_brightness::ControlMarker::NAME => {
                // This stream is closed immediately
                let manager_stream_result =
                    ServerEnd::<fidl_fuchsia_ui_brightness::ControlMarker>::new(channel)
                        .into_stream();

                if manager_stream_result.is_err() {
                    return Box::pin(async {
                        Err(format_err!("could not move brightness channel into stream"))
                    });
                }
                return Box::pin(async { Ok(()) });
            }
            fidl_fuchsia_deprecatedtimezone::TimezoneMarker::NAME => {
                let timezone_stream_result =
                    ServerEnd::<fidl_fuchsia_deprecatedtimezone::TimezoneMarker>::new(channel)
                        .into_stream();

                if timezone_stream_result.is_err() {
                    return Box::pin(async {
                        Err(format_err!("could not move timezone channel into stream"))
                    });
                }
                let mut timezone_stream = timezone_stream_result.unwrap();
                fasync::Task::spawn(async move {
                    while let Some(req) = timezone_stream.try_next().await.unwrap() {
                        match req {
                            fidl_fuchsia_deprecatedtimezone::TimezoneRequest::GetTimezoneId {
                                responder,
                            } => {
                                responder.send("PDT").unwrap();
                            }
                            _ => {}
                        }
                    }
                })
                .detach();
                return Box::pin(async { Ok(()) });
            }
            _ => Box::pin(async { Err(format_err!("unsupported")) }),
        }
    };

    let env = EnvironmentBuilder::new(Arc::new(InMemoryStorageFactory::new()))
        .service(Box::new(service_gen))
        .settings(&[SettingType::Display, SettingType::Intl])
        .spawn_and_get_nested_environment(ENV_NAME)
        .await
        .unwrap();

    let display_proxy = env.connect_to_service::<DisplayMarker>().expect("connected to service");

    let _settings_value = display_proxy.watch().await.expect("watch completed");

    let intl_service = env.connect_to_service::<IntlMarker>().unwrap();
    let _settings = intl_service.watch().await.expect("watch completed");
}

#[fuchsia_async::run_until_stalled(test)]
async fn test_channel_failure_watch() {
    let display_proxy =
        create_display_test_env_with_failures(Arc::new(InMemoryStorageFactory::new())).await;
    let result = display_proxy.watch().await;
    assert_matches!(result, Err(ClientChannelClosed { status: Status::UNAVAILABLE, .. }));
}

// Validate that we can set multiple fields at once.
#[fuchsia_async::run_until_stalled(test)]
async fn test_set_multiple_fields_success() {
    let display_proxy = setup_display_env().await;
    let settings = DisplaySettings {
        auto_brightness: Some(false),
        brightness_value: Some(0.5),
        adjusted_auto_brightness: Some(0.5),
        low_light_mode: Some(FidlLowLightMode::Enable),
        screen_enabled: Some(true),
        theme: Some(FidlTheme {
            theme_type: Some(FidlThemeType::Dark),
            theme_mode: None,
            ..FidlTheme::EMPTY
        }),
        ..DisplaySettings::EMPTY
    };
    display_proxy.set(settings.clone()).await.expect("set completed").expect("set successful");

    let settings_result = display_proxy.watch().await.expect("watch completed");
    assert_eq!(settings_result, settings);
}

async_property_test!(test_set_multiple_fields_brightness => [
    success_case_1(Some(0.7), Some(AUTO_BRIGHTNESS_LEVEL), Some(false), Some(true), true),
    success_case_2(Some(0.7), Some(AUTO_BRIGHTNESS_LEVEL), None, Some(true), true),
    success_case_3(Some(0.7), Some(AUTO_BRIGHTNESS_LEVEL), Some(false), None, true),
    success_case_4(Some(0.7), Some(AUTO_BRIGHTNESS_LEVEL), None, None, true),
    success_case_5(Some(0.7), Some(AUTO_BRIGHTNESS_LEVEL), Some(true), Some(true), true),
    success_case_6(Some(0.7), Some(AUTO_BRIGHTNESS_LEVEL), Some(true), Some(false), true),
    success_case_7(Some(0.7), Some(AUTO_BRIGHTNESS_LEVEL), Some(false), Some(false), true),
]);
async fn test_set_multiple_fields_brightness(
    brightness_value: Option<f32>,
    adjusted_auto_brightness: Option<f32>,
    auto_brightness: Option<bool>,
    screen_enabled: Option<bool>,
    expect_success: bool,
) {
    let display_proxy = setup_display_env().await;

    let settings = DisplaySettings {
        auto_brightness,
        adjusted_auto_brightness,
        brightness_value,
        screen_enabled,
        ..DisplaySettings::EMPTY
    };
    let result = display_proxy.set(settings).await.expect("set completed");
    if expect_success {
        assert!(result.is_ok());
        let settings = display_proxy.watch().await.expect("watch completed");
        assert_eq!(
            settings,
            DisplaySettings {
                auto_brightness: if auto_brightness.is_none() {
                    Some(false)
                } else {
                    auto_brightness
                },
                adjusted_auto_brightness: if adjusted_auto_brightness.is_none() {
                    Some(0.5)
                } else {
                    adjusted_auto_brightness
                },
                brightness_value: if brightness_value.is_none() {
                    Some(0.5)
                } else {
                    brightness_value
                },
                screen_enabled: if screen_enabled.is_none() { Some(true) } else { screen_enabled },
                // Default values untouched.
                low_light_mode: Some(FidlLowLightMode::Disable),
                theme: Some(FidlTheme {
                    theme_type: Some(FidlThemeType::Light),
                    theme_mode: Some(FidlThemeMode::Auto),
                    ..FidlTheme::EMPTY
                }),
                ..DisplaySettings::EMPTY
            }
        );
    } else {
        assert_eq!(result, Err(FidlError::Failed));
    }
}