Port Project Keter's test runner to this project

.gitignore

@@ -1,2 +1,2 @@
 /target
-Cargo.lock
+/Cargo.lock

Cargo.toml

@@ -2,5 +2,10 @@
 members = [ "winit",
     "winit-core", "winit-examples",
     "winit-wayland",
+    "winit-test",
+    "winit-test-runner"
 ]
 resolver = "2"
+
+[workspace.dependencies]
+winit-test = { path = "winit-test" }

ci/build_docker_images.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+set -eu
+
+rx() {
+  echo >&2 "+ $*"
+  "$@"
+}
+build_dockerfile() {
+  tag="$1"
+  name="$2"
+
+  rx docker build . -f dockerfiles/"$name" \
+      -t ghcr.io/notgull/winit_test:"$tag"
+}
+
+build_dockerfile ubuntu Dockerfile.ubuntu

ci/test.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+# MIT/Apache2 License
+
+set -eu
+
+rx() {
+  echo >&2 "+ $*"
+  "$@"
+}
+no_out() {
+  cmd_noout="$1"
+  shift
+  "$cmd_noout" "$@" > /dev/null 2> /dev/null
+}
+bail() {
+  echo "[fatal] $*"
+  exit 1
+}
+info() {
+  echo "[info] $*"
+}
+bail_if_absent() {
+  if ! no_out command -v "$1"; then
+    bail "could not find $1"
+  fi
+}
+test_runner() {
+  bail_if_absent "${CARGO:-cargo}"
+  rx "${CARGO:-cargo}" run --release -p winit-test-runner -- "$@"
+}
+
+basedir="$(dirname -- "$(dirname -- "$0")")"
+cd "$basedir" || exit 1
+
+config_path="${1:-basedir/ci/tests_linux.json}"
+
+# Tell which level of test we're running.
+case "${2:-2}" in
+  0) info "running level 0 (style) tests"; level=0 ;;
+  1) info "running level 1 (function) tests"; level=1 ;;
+  2) info "running level 2 (full) tests"; level=2 ;;
+  *) bail "unknown test level $1" ;;
+esac
+
+# Always run style tests.
+#test_runner style --config "$config_path"
+
+# At level 1 or higher, run functionality tests.
+#if [ "$level" -ge 1 ]; then
+#  test_runner functionality --config "$config_path"
+#fi
+
+# At level 2 or higher, run full tests.
+if [ "$level" -ge 2 ]; then
+  test_runner full --config "$config_path"
+fi

ci/tests_android.json

@@ -0,0 +1,10 @@
+[
+    {
+        "name": "winit-core",
+        "checks": [
+            {
+                "target": "x86_64-linux-android"
+            }
+        ] 
+    }
+]

ci/tests_linux.json

@@ -0,0 +1,10 @@
+[
+    {
+        "name": "winit-core",
+        "checks": [
+            {
+                "target": "x86_64-unknown-linux-gnu"
+            }
+        ] 
+    }
+]

dockerfiles/Dockerfile.ubuntu

@@ -0,0 +1,18 @@
+# Ubuntu testing container
+# Usually tagged as ghcr.io/notgull/winit:ubuntu
+
+FROM rust as final
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN \
+apt-get -o Acquire::Retries=10 -qq update && \
+apt-get -o Acquire::Retries=10 -o Dpkg::Use-Pty=0 install -y --no-install-recommends \
+    xvfb \
+    libx11-dev \
+    libxcb1-dev \
+    libxkbcommon-dev && \
+rm -rf \
+    /var/lib/apt/lists/* \
+    /var/cache/* \
+    /var/log/* \
+    /usr/share/{doc,man}

winit-core/Cargo.toml

@@ -9,3 +9,11 @@ publish = false
 bitflags = "2.4.1"
 raw-window-handle = "0.6.0"
 raw-window-handle-05 = { package = "raw-window-handle", version = "0.5.2" }
+
+[dev-dependencies]
+futures-lite = "2.0.0"
+winit-test.workspace = true
+
+[[example]]
+name = "winit-core_hello_world"
+path = "winit_tests/hello_world/src/lib.rs"

winit-core/winit_tests/hello_world/src/lib.rs

@@ -0,0 +1,14 @@
+// MIT/Apache2 License
+
+use futures_lite::future::block_on;
+
+#[allow(clippy::eq_op)]
+fn main() {
+    winit_test::run_tests(|harness| {
+        block_on(async move {
+            harness.test("hello world", async {
+                assert_eq!(1 + 1, 2)
+            }).await;
+        });
+    })
+}

winit-test-runner/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "winit-test-runner"
+version = "0.1.0"
+edition = "2021"
+authors = ["John Nunley <[email protected]>"]
+publish = false
+
+[dependencies]
+async-channel = "2.1.1"
+async-executor = "1.8.0"
+async-fs = "2.1.0"
+async-io = "2.2.2"
+async-lock = "3.2.0"
+async-process = "2.0.1"
+blocking = "1.5.1"
+clap = "4.4.11"
+color-eyre = "0.6.2"
+eyre = "0.6.11"
+futures-lite = "2.1.0"
+human-panic = "1.2.2"
+ignore = "0.4.21"
+winit-test.workspace = true
+once_cell = "1.19.0"
+owo-colors = "4.0.0"
+pin-project-lite = "0.2.13"
+regex = "1.10.2"
+serde = { version = "1.0.193", features = ["derive"] }
+serde_json = "1.0.108"
+tracing = { version = "0.1.40", default-features = false, features = ["async-await"] }
+tracing-subscriber = "0.3.18"
+which = "5.0.0"

winit-test-runner/README.md

@@ -0,0 +1,23 @@
+# winit-test-runner
+
+Test runner for `winit`.
+
+This binary acts as orchestration for running tests in `winit`. In addition to
+what is often used in normal Rust tests (formatting, Clippy, unit tests), it also
+runs those tests in cross-compilation environments on other platforms.
+
+There are different types of tests:
+
+- **Style tests** make sure that code is formatted and linted properly.
+  `cargo fmt` and `cargo clippy` are used to inspect Rust code.
+- **Functionality tests** run the doctests and unit tests in Rust code. These
+  often ensure that basic functionality and logic are in working order.
+- **Host tests** run the `winit` test suite on the current host. This test suite
+  fully tests the functionality of `winit` to ensure that it is working properly.
+  A full CI run with `winit` should be fully bug-free.
+- **Cross tests** run the `winit` test suite in Docker containers/virtual
+  machines in order to ensure `winit` works on all possible hosts.
+
+## License
+
+MIT/Apache2

winit-test-runner/src/lib.rs

@@ -0,0 +1,4 @@
+// MIT/Apache2 License
+
+mod runner;
+pub use runner::*;

winit-test-runner/src/main.rs

@@ -0,0 +1,79 @@
+// MIT/Apache2 License
+
+mod runner;
+
+use std::path::Path;
+use std::process::exit;
+
+use color_eyre::{eyre::bail, Result};
+use owo_colors::OwoColorize;
+
+fn main() {
+    // Setup error hooks.
+    tracing_subscriber::fmt::try_init().ok();
+    color_eyre::install().ok();
+
+    // Get CLI matches.
+    let matches = cli().get_matches();
+
+    // Run the main function.
+    if let Err(e) = async_io::block_on(entry(matches)) {
+        println!("{}{:?}", "encountered a fatal error: ".red().bold(), e);
+        exit(1);
+    }
+}
+
+async fn entry(matches: clap::ArgMatches) -> Result<()> {
+    match matches.subcommand() {
+        None => bail!("expected a subcommand"),
+        Some(("style", matches)) => {
+            let crates = read_config(matches.get_one::<String>("config").unwrap()).await?;
+            runner::Test::Style.run(crates).await?;
+        }
+        Some(("functionality", matches)) => {
+            let crates = read_config(matches.get_one::<String>("config").unwrap()).await?;
+            runner::Test::Functionality.run(crates).await?;
+        }
+        Some(("full", matches)) => {
+            let crates = read_config(matches.get_one::<String>("config").unwrap()).await?;
+            runner::Test::Host.run(crates).await?;
+        }
+        Some((subcommand, _matches)) => bail!("unknown subcommand {subcommand}"),
+    }
+
+    Ok(())
+}
+
+async fn read_config(path: impl AsRef<Path>) -> Result<Vec<runner::Crate>> {
+    let data = async_fs::read(path).await?;
+    let crates = serde_json::from_slice(&data)?;
+    Ok(crates)
+}
+
+fn cli() -> clap::Command {
+    clap::Command::new("winit-test-runner")
+        .subcommand(
+            clap::Command::new("style").arg(
+                clap::Arg::new("config")
+                    .required(true)
+                    .short('c')
+                    .long("config"),
+            ),
+        )
+        .subcommand(
+            clap::Command::new("functionality").arg(
+                clap::Arg::new("config")
+                    .required(true)
+                    .short('c')
+                    .long("config"),
+            ),
+        )
+        .subcommand(
+            clap::Command::new("full").arg(
+                clap::Arg::new("config")
+                    .required(true)
+                    .short('c')
+                    .long("config"),
+            ),
+        )
+}