Test setup for WebAssembly+WebGL

.github/workflows/ci.yml

@@ -161,6 +161,33 @@ jobs:
           # build docs
           cargo doc --target ${{ matrix.target }} -p wgpu -p wgpu-core -p wgpu-info -p player --all-features --no-deps
 
+  wasm-test:
+    name: Test Wasm
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout repo
+        uses: actions/checkout@v3
+
+      - name: install rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+# doesn't work for this project because of https://github.com/rustwasm/wasm-pack/issues/1180
+#      - name: install wasm-pack
+#        uses: jetli/wasm-pack-action@v0.4.0
+#
+# install from fork until this is merged: https://github.com/rustwasm/wasm-pack/pull/1185
+      - name: install wasm-pack
+        run: |
+          cargo install --git https://github.com/haraldreingruber/wasm-pack wasm-pack
+
+      - name: execute tests
+        run: |
+          cd wgpu
+          wasm-pack test --headless --chrome --features webgl
+
   gpu-test:
     strategy:
       fail-fast: false

Cargo.toml

@@ -112,6 +112,7 @@ console_log = "0.2"
 js-sys = "0.3.60"
 wasm-bindgen = "0.2.83"
 wasm-bindgen-futures = "0.4.33"
+wasm-bindgen-test = "0.3"
 web-sys = "0.3.60"
 
 # deno dependencies

wgpu/Cargo.toml

@@ -126,7 +126,8 @@ obj.workspace = true
 pollster.workspace = true
 png.workspace = true
 nanorand = { workspace = true, features = ["wyrand"] }
-winit.workspace = true                                 # for "halmark" example                                                        # for "halmark" example
+wasm-bindgen-test.workspace = true
+winit.workspace = true # for "halmark" example
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 async-executor.workspace = true
@@ -283,12 +284,13 @@ parking_lot.workspace = true
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 console_error_panic_hook.workspace = true
 console_log.workspace = true
-# We need these features in the framework examples
+# We need these features in the framework examples and tests
 web-sys = { workspace = true, features = [
     "Location",
     "Blob",
     "RequestInit",
     "RequestMode",
     "Request",
-    "Response"
+    "Response",
+    "WebGl2RenderingContext"
 ] }

wgpu/tests/buffer_usages.rs

@@ -1,11 +1,15 @@
 //! Tests for buffer usages validation.
 
 use crate::common::{fail_if, initialize_test, TestParameters};
+use wasm_bindgen_test::*;
 use wgt::BufferAddress;
 
+wasm_bindgen_test_configure!(run_in_browser);
+
 const BUFFER_SIZE: BufferAddress = 1234;
 
 #[test]
+#[wasm_bindgen_test]
 fn buffer_usage() {
     fn try_create(enable_mappable_primary_buffers: bool, usages: &[(bool, &[wgpu::BufferUsages])]) {
         let mut parameters = TestParameters::default();

wgpu/tests/clear_texture.rs

@@ -1,6 +1,9 @@
 use crate::common::{initialize_test, TestParameters, TestingContext};
+use wasm_bindgen_test::*;
 use wgpu::util::align_to;
 
+wasm_bindgen_test_configure!(run_in_browser);
+
 static TEXTURE_FORMATS_UNCOMPRESSED: &[wgpu::TextureFormat] = &[
     wgpu::TextureFormat::R8Unorm,
     wgpu::TextureFormat::R8Snorm,
@@ -304,6 +307,7 @@ fn clear_texture_tests(
 }
 
 #[test]
+#[wasm_bindgen_test]
 fn clear_texture_2d_uncompressed() {
     initialize_test(
         TestParameters::default().features(wgpu::Features::CLEAR_TEXTURE),
@@ -315,6 +319,7 @@ fn clear_texture_2d_uncompressed() {
 }
 
 #[test]
+#[wasm_bindgen_test]
 fn clear_texture_d32_s8() {
     initialize_test(
         TestParameters::default()

wgpu/tests/common/mod.rs

@@ -5,10 +5,17 @@ use std::panic::{catch_unwind, AssertUnwindSafe};
 
 use wgt::{Backends, DeviceDescriptor, DownlevelCapabilities, Features, Limits};
 
-use wgpu::{util, Adapter, Device, DownlevelFlags, Instance, Queue};
+use wgpu::{Adapter, Device, DownlevelFlags, Instance, Queue};
+
+#[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+use wasm_bindgen::JsCast;
+#[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+use web_sys::HtmlCanvasElement;
 
 pub mod image;
 
+const CANVAS_ID: &str = "test-canvas";
+
 async fn initialize_device(
     adapter: &Adapter,
     features: Features,
@@ -170,14 +177,7 @@ pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(Te
     // We don't actually care if it fails
     let _ = env_logger::try_init();
 
-    let backend_bits = util::backend_bits_from_env().unwrap_or_else(Backends::all);
-    let instance = Instance::new(backend_bits);
-    let adapter = pollster::block_on(util::initialize_adapter_from_env_or_default(
-        &instance,
-        backend_bits,
-        None,
-    ))
-    .expect("could not find suitable adapter on the system");
+    let adapter = initialize_adapter();
 
     let adapter_info = adapter.get_info();
     let adapter_lowercase_name = adapter_info.name.to_lowercase();
@@ -187,18 +187,28 @@ pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(Te
 
     let missing_features = parameters.required_features - adapter_features;
     if !missing_features.is_empty() {
+        #[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+        delete_html_canvas();
+
+        // TODO: we probably should use log crate here for logging also to wasm console
         println!("TEST SKIPPED: MISSING FEATURES {:?}", missing_features);
         return;
     }
 
     if !parameters.required_limits.check_limits(&adapter_limits) {
+        #[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+        delete_html_canvas();
+
         println!("TEST SKIPPED: LIMIT TOO LOW");
         return;
     }
 
     let missing_downlevel_flags =
         parameters.required_downlevel_properties.flags - adapter_downlevel_capabilities.flags;
     if !missing_downlevel_flags.is_empty() {
+        #[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+        delete_html_canvas();
+
         println!(
             "TEST SKIPPED: MISSING DOWNLEVEL FLAGS {:?}",
             missing_downlevel_flags
@@ -209,6 +219,9 @@ pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(Te
     if adapter_downlevel_capabilities.shader_model
         < parameters.required_downlevel_properties.shader_model
     {
+        #[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+        delete_html_canvas();
+
         println!(
             "TEST SKIPPED: LOW SHADER MODEL {:?}",
             adapter_downlevel_capabilities.shader_model
@@ -273,6 +286,9 @@ pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(Te
     });
 
     if let Some((reason, true)) = expected_failure_reason {
+        #[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+        delete_html_canvas();
+
         println!("EXPECTED TEST FAILURE SKIPPED: {:?}", reason);
         return;
     }
@@ -314,6 +330,60 @@ pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(Te
     }
 }
 
+#[cfg(not(all(target_arch = "wasm32", feature = "webgl")))]
+fn initialize_adapter() -> Adapter {
+    let backend_bits = wgpu::util::backend_bits_from_env().unwrap_or_else(Backends::all);
+    let instance = Instance::new(backend_bits);
+
+    pollster::block_on(wgpu::util::initialize_adapter_from_env_or_default(
+        &instance,
+        backend_bits,
+        None,
+    ))
+    .expect("could not find suitable adapter on the system")
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+fn initialize_adapter() -> Adapter {
+    // On wasm, append a canvas to the document body for initializing the adapter
+    delete_html_canvas(); // if there is a previous one
+    let canvas = create_html_canvas();
+
+    let instance = Instance::new(Backends::GL);
+    let surface = instance.create_surface_from_canvas(&canvas);
+
+    pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+        power_preference: wgpu::PowerPreference::default(),
+        force_fallback_adapter: false,
+        // Request an adapter which can render to our surface
+        compatible_surface: Some(&surface),
+    }))
+    .expect("could not find suitable adapter on the system")
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+fn create_html_canvas() -> HtmlCanvasElement {
+    web_sys::window()
+        .and_then(|win| win.document())
+        .and_then(|doc| {
+            let body = doc.body().unwrap();
+            let canvas = doc.create_element("Canvas").unwrap();
+            canvas.set_id(CANVAS_ID);
+            body.append_child(&canvas).unwrap();
+            canvas.dyn_into::<web_sys::HtmlCanvasElement>().ok()
+        })
+        .expect("couldn't append canvas to document body")
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "webgl"))]
+fn delete_html_canvas() {
+    if let Some(document) = web_sys::window().and_then(|win| win.document()) {
+        if let Some(element) = document.get_element_by_id(CANVAS_ID) {
+            element.remove();
+        }
+    };
+}
+
 // Run some code in an error scope and assert that validation fails.
 pub fn fail<T>(device: &wgpu::Device, callback: impl FnOnce() -> T) -> T {
     device.push_error_scope(wgpu::ErrorFilter::Validation);

wgpu/tests/device.rs

@@ -1,6 +1,11 @@
+use wasm_bindgen_test::*;
+
 use crate::common::{initialize_test, TestParameters};
 
+wasm_bindgen_test_configure!(run_in_browser);
+
 #[test]
+#[wasm_bindgen_test]
 fn device_initialization() {
     initialize_test(TestParameters::default(), |_ctx| {
         // intentionally empty

wgpu/tests/encoder.rs

@@ -1,6 +1,10 @@
 use crate::common::{initialize_test, TestParameters};
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
 
 #[test]
+#[wasm_bindgen_test]
 fn drop_encoder() {
     initialize_test(TestParameters::default(), |ctx| {
         let encoder = ctx

wgpu/tests/poll.rs

@@ -7,6 +7,9 @@ use wgpu::{
 };
 
 use crate::common::{initialize_test, TestParameters, TestingContext};
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
 
 fn generate_dummy_work(ctx: &TestingContext) -> CommandBuffer {
     let buffer = ctx.device.create_buffer(&BufferDescriptor {
@@ -53,6 +56,7 @@ fn generate_dummy_work(ctx: &TestingContext) -> CommandBuffer {
 }
 
 #[test]
+#[wasm_bindgen_test]
 fn wait() {
     initialize_test(TestParameters::default().skip(), |ctx| {
         let cmd_buf = generate_dummy_work(&ctx);
@@ -63,6 +67,7 @@ fn wait() {
 }
 
 #[test]
+#[wasm_bindgen_test]
 fn double_wait() {
     initialize_test(TestParameters::default().skip(), |ctx| {
         let cmd_buf = generate_dummy_work(&ctx);
@@ -74,6 +79,7 @@ fn double_wait() {
 }
 
 #[test]
+#[wasm_bindgen_test]
 fn wait_on_submission() {
     initialize_test(TestParameters::default().skip(), |ctx| {
         let cmd_buf = generate_dummy_work(&ctx);
@@ -84,6 +90,7 @@ fn wait_on_submission() {
 }
 
 #[test]
+#[wasm_bindgen_test]
 fn double_wait_on_submission() {
     initialize_test(TestParameters::default().skip(), |ctx| {
         let cmd_buf = generate_dummy_work(&ctx);
@@ -95,6 +102,7 @@ fn double_wait_on_submission() {
 }
 
 #[test]
+#[wasm_bindgen_test]
 fn wait_out_of_order() {
     initialize_test(TestParameters::default().skip(), |ctx| {
         let cmd_buf1 = generate_dummy_work(&ctx);

wgpu/tests/queue_transfer.rs

@@ -3,8 +3,12 @@
 use std::num::NonZeroU32;
 
 use crate::common::{fail, initialize_test, TestParameters};
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
 
 #[test]
+#[wasm_bindgen_test]
 fn queue_write_texture_overflow() {
     initialize_test(TestParameters::default(), |ctx| {
         let texture = ctx.device.create_texture(&wgpu::TextureDescriptor {

wgpu/tests/resource_descriptor_accessor.rs

@@ -1,7 +1,11 @@
 use crate::common::{initialize_test, TestParameters};
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
 
 /// Buffer's size and usage can be read back.
 #[test]
+#[wasm_bindgen_test]
 fn buffer_size_and_usage() {
     initialize_test(TestParameters::default(), |ctx| {
         let buffer = ctx.device.create_buffer(&wgpu::BufferDescriptor {