web: Add swf-tests package, for running the swf test suite in a browser

Author: Dinnerbone

Cargo.lock

@@ -8,6 +8,7 @@ members = [
     "flv",
     "web",
     "web/packages/extension/safari",
+    "web/packages/swf-tests/runner",
     "wstr",
     "scanner",
     "exporter",

Cargo.toml

@@ -71,4 +71,5 @@ unknown-git = "deny"
 #  github.com organizations to allow git sources for
 github = [
     "ruffle-rs",
+    "manuel-woelker", # https://github.com/manuel-woelker/rust-vfs
 ]

deny.toml

@@ -85,6 +85,28 @@ impl WgpuRenderBackend<SwapChainTarget> {
         Self::new(Arc::new(descriptors), target)
     }
 
+    #[cfg(target_family = "wasm")]
+    pub async fn descriptors_for_offscreen_canvas(
+        backends: wgpu::Backends,
+        canvas: web_sys::OffscreenCanvas,
+    ) -> Result<Arc<Descriptors>, Error> {
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+            backends,
+            ..Default::default()
+        });
+        let surface = instance.create_surface(wgpu::SurfaceTarget::OffscreenCanvas(canvas))?;
+        let (adapter, device, queue) = request_adapter_and_device(
+            backends,
+            &instance,
+            Some(&surface),
+            wgpu::PowerPreference::HighPerformance,
+            None,
+        )
+        .await?;
+        let descriptors = Descriptors::new(instance, adapter, device, queue);
+        Ok(Arc::new(descriptors))
+    }
+
     /// # Safety
     ///  See [`wgpu::SurfaceTargetUnsafe`] variants for safety requirements.
     #[cfg(not(target_family = "wasm"))]
@@ -134,8 +156,8 @@ impl WgpuRenderBackend<SwapChainTarget> {
     }
 }
 
-#[cfg(not(target_family = "wasm"))]
 impl WgpuRenderBackend<crate::target::TextureTarget> {
+    #[cfg(not(target_family = "wasm"))]
     pub fn for_offscreen(
         size: (u32, u32),
         backend: wgpu::Backends,

package-lock.json

@@ -154,7 +154,6 @@ pub fn capture_image<R, F: FnOnce(&[u8], u32) -> R>(
     result
 }
 
-#[cfg(not(target_family = "wasm"))]
 pub fn buffer_to_image(
     device: &wgpu::Device,
     buffer: &wgpu::Buffer,

render/wgpu/src/backend.rs

@@ -27,7 +27,7 @@ serde = "1.0.196"
 toml = "0.8.9"
 anyhow = "1.0.79"
 async-channel = "2.1.1"
-vfs = "0.10.0"
+vfs = { git = "https://github.com/manuel-woelker/rust-vfs", rev = "722ecc60b76c90fd7ce4c6dac6114bc13271cb65" }
 percent-encoding = "2.3.1"
 
 [features]

render/wgpu/src/utils.rs

@@ -146,7 +146,7 @@ impl RequiredFeatures {
 pub struct PlayerOptions {
     max_execution_duration: Option<Duration>,
     viewport_dimensions: Option<ViewportDimensions>,
-    with_renderer: Option<RenderOptions>,
+    pub with_renderer: Option<RenderOptions>,
     with_audio: bool,
     with_video: bool,
     runtime: PlayerRuntime,
@@ -371,7 +371,7 @@ impl ImageComparison {
 #[derive(Clone, Deserialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct RenderOptions {
-    optional: bool,
+    pub optional: bool,
     pub sample_count: u32,
     pub exclude_warp: bool,
 }

tests/framework/Cargo.toml

@@ -0,0 +1,91 @@
+use crate::options::{Approximations, ImageComparison};
+use image::RgbaImage;
+
+#[derive(Default)]
+pub struct TestResults {
+    pub results: Vec<TestResult>,
+}
+
+impl TestResults {
+    pub fn success(&self) -> bool {
+        self.results.iter().all(|img| img.success())
+    }
+
+    pub fn add(&mut self, result: impl Into<TestResult>) {
+        self.results.push(result.into());
+    }
+}
+
+pub enum TestResult {
+    Trace(TraceComparisonResult),
+    Approximation(NumberApproximationResult),
+    Image(ImageComparisonResult),
+    InvalidTest(String),
+}
+
+impl TestResult {
+    pub fn success(&self) -> bool {
+        match self {
+            TestResult::Trace(result) => result.success(),
+            TestResult::Approximation(result) => result.success(),
+            TestResult::Image(result) => result.success(),
+            TestResult::InvalidTest(_) => false,
+        }
+    }
+}
+
+impl From<String> for TestResult {
+    fn from(value: String) -> Self {
+        TestResult::InvalidTest(value)
+    }
+}
+
+pub struct TraceComparisonResult {
+    pub expected: String,
+    pub actual: String,
+}
+
+impl TraceComparisonResult {
+    pub fn success(&self) -> bool {
+        self.expected == self.actual
+    }
+}
+
+pub struct NumberApproximationResult {
+    pub line: usize,
+    pub expected: f64,
+    pub actual: f64,
+    pub options: Approximations,
+    pub group: Option<u32>,
+    pub surrounding_text: Option<TraceComparisonResult>,
+}
+
+impl NumberApproximationResult {
+    pub fn success(&self) -> bool {
+        if let Some(surrounding_text) = &self.surrounding_text {
+            if !surrounding_text.success() {
+                return false;
+            }
+        }
+        // NaNs should be able to pass in an approx test.
+        if self.actual.is_nan() && self.expected.is_nan() {
+            return true;
+        }
+        self.options.compare(self.actual, self.expected)
+    }
+}
+
+pub struct ImageComparisonResult {
+    pub name: String,
+    pub expected: RgbaImage,
+    pub actual: RgbaImage,
+    pub difference_color: Option<RgbaImage>,
+    pub difference_alpha: Option<RgbaImage>,
+    pub options: ImageComparison,
+}
+
+impl ImageComparisonResult {
+    pub fn success(&self) -> bool {
+        self.expected == self.actual
+    }
+}