use std::path::Path;
use std::process::{Command, Output};
use native_theme_gtk::{Rgba, ThemeSnapshot};
fn command() -> Command {
Command::new(env!("CARGO_BIN_EXE_native-theme-gtk"))
}
fn parse_success(output: Output) -> ThemeSnapshot {
assert!(
output.status.success(),
"probe failed: {}",
String::from_utf8_lossy(&output.stderr)
);
serde_json::from_slice(&output.stdout).expect("probe emitted invalid JSON")
}
fn run_theme(theme: &str, config_home: Option<&Path>) -> ThemeSnapshot {
let mut process = command();
process.env("GTK_THEME", theme);
if let Some(config_home) = config_home {
process.env("XDG_CONFIG_HOME", config_home);
}
parse_success(process.output().expect("failed to run GTK probe"))
}
fn live_tests_enabled() -> bool {
std::env::var_os("NATIVE_THEME_RUN_LIVE_TESTS").is_some()
}
fn approximately_equal(actual: Rgba, expected: Rgba) -> bool {
const TOLERANCE: f32 = 1.0 / 255.0;
(actual.red - expected.red).abs() <= TOLERANCE
&& (actual.green - expected.green).abs() <= TOLERANCE
&& (actual.blue - expected.blue).abs() <= TOLERANCE
&& (actual.alpha - expected.alpha).abs() <= TOLERANCE
}
#[test]
fn unavailable_display_backend_fails_cleanly() {
let output = command()
.env("GDK_BACKEND", "native-theme-no-such-backend")
.output()
.expect("failed to run GTK probe");
assert!(!output.status.success());
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(stderr.contains("failed to initialize GTK"), "{stderr}");
}
#[test]
fn adwaita_light_and_dark_are_distinct() {
if !live_tests_enabled() {
return;
}
let light = run_theme("Adwaita", None);
let dark = run_theme("Adwaita:dark", None);
let light_background = light.semantic_palette.window_background.unwrap();
let dark_background = dark.semantic_palette.window_background.unwrap();
let light_bridge = light.resolve_native_theme().unwrap();
let dark_bridge = dark.resolve_native_theme().unwrap();
assert!(light_background.red > dark_background.red);
assert!(light_background.green > dark_background.green);
assert!(!light_bridge.mode.is_dark());
assert!(dark_bridge.mode.is_dark());
assert_eq!(
light_bridge
.resolved
.defaults
.background_color
.to_f32_array(),
[
light_background.red,
light_background.green,
light_background.blue,
light_background.alpha,
]
);
assert_eq!(
light_bridge.resolved.scrollbar.overlay_mode,
light.settings.overlay_scrolling.unwrap()
);
assert_eq!(light.backend, "gtk4");
assert_eq!(light.widgets.len(), 8);
#[cfg(feature = "gpui")]
{
let light_gpui = light.to_gpui_theme().unwrap();
let dark_gpui = dark.to_gpui_theme().unwrap();
assert!(!light_gpui.is_dark());
assert!(dark_gpui.is_dark());
}
let minor = light
.identity
.toolkit_version
.split('.')
.nth(1)
.unwrap()
.parse::<u32>()
.unwrap();
if minor >= 20 {
assert!(light.settings.interface_color_scheme.is_some());
assert!(light.settings.interface_contrast.is_some());
}
if minor >= 22 {
assert!(light.settings.interface_reduced_motion.is_some());
}
}
#[test]
fn user_css_overrides_are_resolved() {
if !live_tests_enabled() {
return;
}
let config = tempfile::tempdir().unwrap();
let gtk_config = config.path().join("gtk-4.0");
std::fs::create_dir(>k_config).unwrap();
std::fs::write(
gtk_config.join("gtk.css"),
"@define-color window_bg_color #123456;\n@define-color window_fg_color #fedcba;\n",
)
.unwrap();
let snapshot = run_theme("Adwaita", Some(config.path()));
let expected_background = Rgba {
red: 0x12 as f32 / 255.0,
green: 0x34 as f32 / 255.0,
blue: 0x56 as f32 / 255.0,
alpha: 1.0,
};
let expected_text = Rgba {
red: 0xfe as f32 / 255.0,
green: 0xdc as f32 / 255.0,
blue: 0xba as f32 / 255.0,
alpha: 1.0,
};
assert!(approximately_equal(
snapshot.semantic_palette.window_background.unwrap(),
expected_background
));
assert!(approximately_equal(
snapshot.semantic_palette.window_text.unwrap(),
expected_text
));
let bridge = snapshot.resolve_native_theme().unwrap();
assert_eq!(
bridge.resolved.defaults.background_color.to_f32_array(),
[
expected_background.red,
expected_background.green,
expected_background.blue,
expected_background.alpha,
]
);
#[cfg(feature = "gpui")]
assert_eq!(
snapshot.to_gpui_theme().unwrap().is_dark(),
bridge.mode.is_dark()
);
}
#[test]
fn repeated_probes_are_deterministic() {
if !live_tests_enabled() {
return;
}
let first = run_theme("Adwaita", None);
let second = run_theme("Adwaita", None);
assert_eq!(first, second);
}
#[test]
fn desktop_color_scheme_matches_the_effective_theme_mode() {
if !live_tests_enabled() {
return;
}
let snapshot = parse_success(
command()
.env_remove("GTK_THEME")
.output()
.expect("failed to run GTK probe"),
);
let Some(color_scheme) = snapshot.settings.interface_color_scheme.as_ref() else {
return;
};
let expected_dark = match color_scheme.nick.as_str() {
"dark" => true,
"light" => false,
_ => return,
};
let bridge = snapshot.resolve_native_theme().unwrap();
assert_eq!(
bridge.mode.is_dark(),
expected_dark,
"GTK sampled colors did not honor the desktop's explicit {} preference",
color_scheme.nick
);
assert_eq!(snapshot.settings.prefer_dark, Some(expected_dark));
}