tests: refactor e2e test and add shader tests

* Refactored e2e tests into more of their own files.
* Added shader and animated_cursor tests.
* Added the software GPU `lavapipe` to Github actions.

Author: tombh

.github/workflows/ci.yaml

@@ -37,7 +37,16 @@ jobs:
     steps:
       - if: matrix.os == 'ubuntu-latest'
         name: Install Linux system dependencies
-        run: sudo apt-get install libxcb1-dev libdbus-1-dev
+        run: |
+          sudo apt-get install \
+            libxcb1-dev libdbus-1-dev \
+            mesa-vulkan-drivers \
+            libvulkan1 \
+            vulkan-tools \
+            vulkan-validationlayers \
+            libasound2-dev \
+            libudev-dev
+          vulkaninfo
       - if: matrix.os == 'macos-latest'
         name: Install MacOS dependencies
         run: brew install bash nano watch
@@ -50,8 +59,16 @@ jobs:
           cache-on-failure: true
       - name: Build
         run: cargo build --verbose --all
-      - name: Run tests
-        run: cargo nextest run --no-fail-fast --retries 2
+      - name: Run tests (excluding GPU tests)
+        # Multiline escapes don't work on Windows
+        run: |
+          cargo nextest run --filterset 'not (test(/gpu/))' --no-fail-fast --retries 2
+      - if: matrix.os == 'ubuntu-latest'
+        name: Run GPU tests
+        run: |
+          cargo nextest run \
+            --filterset 'test(/gpu/)' \
+            --no-fail-fast --retries 2
       - name: Output e2e test logs (on failure)
         if: failure()
         run: cat crates/tests/tattoy.log

Cargo.lock

@@ -23,7 +23,7 @@ tracing = "0.1.40"
 tracing-subscriber = {version = "0.3.18", features = ["env-filter"]}
 
 [workspace.dependencies.shadow-terminal]
-version = "0.2.1"
+version = "0.2.2"
 # path = "../shadow-terminal/shadow-terminal/"
 
 # Canonical lints for whole crate

Cargo.toml

@@ -6,9 +6,40 @@ use color_eyre::eyre::Result;
 
 use crate::{run::FrameUpdate, tattoys::gpu::shaderer::Shaderer as _};
 
+/// Start all the enabled tattoys.
+pub(crate) async fn start_tattoys(
+    enabled_tattoys: Vec<String>,
+    output: tokio::sync::mpsc::Sender<FrameUpdate>,
+    state: Arc<crate::shared_state::SharedState>,
+) -> std::thread::JoinHandle<Result<(), color_eyre::eyre::Error>> {
+    convert_cli_enabled_args(&enabled_tattoys, &state).await;
+    let handle = spawn(enabled_tattoys.clone(), output, Arc::clone(&state));
+    wait_for_enabled_tattoys_to_start(enabled_tattoys, &state).await;
+    handle
+}
+
+/// Centralise all "enabled" settings into the state config. Saves us having to check both the CLI
+/// and state everytime.
+async fn convert_cli_enabled_args(
+    enabled_tattoys: &Vec<String>,
+    state: &Arc<crate::shared_state::SharedState>,
+) {
+    for tattoy in enabled_tattoys {
+        match tattoy.as_ref() {
+            "startup_logo" => state.config.write().await.show_startup_logo = true,
+            "notifications" => state.config.write().await.notifications.enabled = true,
+            "minimap" => state.config.write().await.minimap.enabled = true,
+            "shaders" => state.config.write().await.shader.enabled = true,
+            "animated_cursor" => state.config.write().await.animated_cursor.enabled = true,
+            "bg_command" => state.config.write().await.bg_command.enabled = true,
+            _ => (),
+        }
+    }
+}
+
 /// Start the main loader thread
 #[expect(clippy::too_many_lines, reason = "It's mostly repetitive")]
-pub(crate) fn start_tattoys(
+pub(crate) fn spawn(
     enabled_tattoys: Vec<String>,
     output: tokio::sync::mpsc::Sender<FrameUpdate>,
     state: Arc<crate::shared_state::SharedState>,
@@ -21,9 +52,7 @@ pub(crate) fn start_tattoys(
             let palette = crate::config::main::Config::load_palette(Arc::clone(&state)).await?;
             let mut tattoy_futures = tokio::task::JoinSet::new();
 
-            if enabled_tattoys.contains(&"startup_logo".to_owned())
-                || state.config.read().await.show_startup_logo
-            {
+            if state.config.read().await.show_startup_logo {
                 tracing::info!("Starting 'startup_logo' tattoy...");
                 tattoy_futures.spawn(crate::tattoys::startup_logo::StartupLogo::start(
                     output.clone(),
@@ -32,9 +61,7 @@ pub(crate) fn start_tattoys(
                 ));
             }
 
-            if enabled_tattoys.contains(&"notifications".to_owned())
-                || state.config.read().await.notifications.enabled
-            {
+            if state.config.read().await.notifications.enabled {
                 tracing::info!("Starting 'notifications' tattoy...");
                 tattoy_futures.spawn(crate::tattoys::notifications::main::Notifications::start(
                     output.clone(),
@@ -58,39 +85,31 @@ pub(crate) fn start_tattoys(
                 ));
             }
 
-            if enabled_tattoys.contains(&"minimap".to_owned())
-                || state.config.read().await.minimap.enabled
-            {
+            if state.config.read().await.minimap.enabled {
                 tracing::info!("Starting 'minimap' tattoy...");
                 tattoy_futures.spawn(crate::tattoys::minimap::Minimap::start(
                     output.clone(),
                     Arc::clone(&state),
                 ));
             }
 
-            if enabled_tattoys.contains(&"shaders".to_owned())
-                || state.config.read().await.shader.enabled
-            {
+            if state.config.read().await.shader.enabled {
                 tracing::info!("Starting 'shaders' tattoy...");
                 tattoy_futures.spawn(crate::tattoys::shader::Shaders::start(
                     output.clone(),
                     Arc::clone(&state),
                 ));
             }
 
-            if enabled_tattoys.contains(&"animated_cursor".to_owned())
-                || state.config.read().await.animated_cursor.enabled
-            {
+            if state.config.read().await.animated_cursor.enabled {
                 tracing::info!("Starting 'animated_cursor' tattoy...");
                 tattoy_futures.spawn(crate::tattoys::animated_cursor::AnimatedCursor::start(
                     output.clone(),
                     Arc::clone(&state),
                 ));
             }
 
-            if enabled_tattoys.contains(&"bg_command".to_owned())
-                || state.config.read().await.bg_command.enabled
-            {
+            if state.config.read().await.bg_command.enabled {
                 tracing::info!("Starting 'bg_command' tattoy...");
                 tattoy_futures.spawn(crate::tattoys::bg_command::BGCommand::start(
                     output.clone(),
@@ -140,3 +159,25 @@ pub(crate) fn start_tattoys(
         })
     })
 }
+
+/// Wait for tattoys that need to be running before the PTY starts.
+async fn wait_for_enabled_tattoys_to_start(
+    enabled_tattoys: Vec<String>,
+    state: &Arc<crate::shared_state::SharedState>,
+) {
+    if enabled_tattoys.contains(&"random_walker".to_owned()) {
+        crate::run::wait_for_system(state, "random_walker").await;
+    }
+
+    if state.config.read().await.shader.enabled {
+        crate::run::wait_for_system(state, "shader").await;
+    }
+
+    if state.config.read().await.minimap.enabled {
+        crate::run::wait_for_system(state, "minimap").await;
+    }
+
+    if state.config.read().await.animated_cursor.enabled {
+        crate::run::wait_for_system(state, "animated_cursor").await;
+    }
+}

crates/tattoy/src/loader.rs

@@ -97,7 +97,8 @@ pub(crate) async fn run(state_arc: &std::sync::Arc<SharedState>) -> Result<()> {
         cli_args.enabled_tattoys.clone(),
         surfaces_tx.clone(),
         Arc::clone(state_arc),
-    );
+    )
+    .await;
 
     let scrollback_size = state_arc.config.read().await.scrollback_size;
     let shadow_terminal_config = shadow_terminal::shadow_terminal::Config {

crates/tattoy/src/run.rs

@@ -90,6 +90,12 @@ impl BGCommand {
         let mut protocol = state.protocol_tx.subscribe();
         let mut commander = Self::new(output, &state, palette).await;
 
+        state
+            .initialised_systems
+            .write()
+            .await
+            .push("bg_command".to_owned());
+
         #[expect(
             clippy::integer_division_remainder_used,
             reason = "This is caused by the `tokio::select!`"

crates/tattoy/src/tattoys/bg_command.rs

@@ -127,6 +127,12 @@ pub(crate) trait Shaderer: Sized {
         let mut protocol = state.protocol_tx.subscribe();
         let mut shader = Self::new(output, std::sync::Arc::clone(state)).await?;
 
+        state
+            .initialised_systems
+            .write()
+            .await
+            .push(shader.tattoy().id.clone());
+
         #[expect(
             clippy::integer_division_remainder_used,
             reason = "This is caused by the `tokio::select!`"
@@ -188,6 +194,7 @@ pub(crate) trait Shaderer: Sized {
     /// Tick the render
     async fn render(&mut self) -> Result<()> {
         let rendered_pixels = self.gpu_mut().render().await?;
+        tracing::info!("!!");
 
         if self.is_upload_tty_as_pixels().await {
             if self.gpu().tty_pixels.dimensions().1 == 0 {

crates/tattoy/src/tattoys/gpu/shaderer.rs

@@ -89,7 +89,12 @@ impl Minimap {
         state: Arc<crate::shared_state::SharedState>,
     ) -> Result<()> {
         let mut protocol = state.protocol_tx.subscribe();
-        let mut minimap = Self::new(output, state).await;
+        let mut minimap = Self::new(output, Arc::clone(&state)).await;
+        state
+            .initialised_systems
+            .write()
+            .await
+            .push("minimap".to_owned());
 
         #[expect(
             clippy::integer_division_remainder_used,

crates/tattoy/src/tattoys/minimap.rs

@@ -54,7 +54,13 @@ impl RandomWalker {
         state: std::sync::Arc<crate::shared_state::SharedState>,
     ) -> Result<()> {
         let mut protocol = state.protocol_tx.subscribe();
-        let mut random_walker = Self::new(output, state).await;
+        let mut random_walker = Self::new(output, std::sync::Arc::clone(&state)).await;
+
+        state
+            .initialised_systems
+            .write()
+            .await
+            .push("random_walker".to_owned());
 
         #[expect(
             clippy::integer_division_remainder_used,

crates/tattoy/src/tattoys/random_walker.rs

@@ -40,7 +40,25 @@ pub(crate) fn simple_hash(input: &[u8]) -> u64 {
     let mut hash: u64 = 0;
     for byte in input {
         let byte_u64 = u64::from(*byte);
-        hash = ((hash << 5u8) + hash) + byte_u64;
+        let shifted = safe_add(hash << 5u8, hash);
+        hash = safe_add(shifted, byte_u64);
     }
     hash
 }
+
+/// Safely add 2 `u64`s by wrapping on overflow.
+#[expect(
+    clippy::as_conversions,
+    clippy::cast_possible_truncation,
+    clippy::integer_division_remainder_used,
+    reason = "u64 always fits into u128"
+)]
+const fn safe_add(left: u64, right: u64) -> u64 {
+    match left.checked_add(right) {
+        Some(result) => result,
+        None => {
+            let wrapped_result = (left as u128 + right as u128) % (u64::MAX as u128 + 1);
+            wrapped_result as u64
+        }
+    }
+}