pepepper/fluxer
1
0 Fork 0
mirror of https://github.com/fluxerapp/fluxer synced 2026-10-18 05:25:40 +09:00
Code Issues Packages Projects Releases Wiki Activity

test: remove infrastructure-dependent integration suites (#1573)

Browse Source
This commit is contained in:
Hampus authored and GitHub committed 2026-08-12 16:56:25 +02:00
1 parent f88b0f69b2
commit 10fc79ab37
199 files changed
+688 -46963
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

fluxer_desktop/native/screen-frame-bus/src/gpu_loss.rs
+2 -224
View File
@@ -193,216 +193,10 @@ fn build_resources(device: &wgpu::Device, config: WgpuStagingConfig) -> WgpuStag
}
}
pub fn try_acquire_device() -> Option<(wgpu::Device, wgpu::Queue, wgpu::Instance)> {
let mut descriptor = wgpu::InstanceDescriptor::new_without_display_handle();
descriptor.backends = wgpu::Backends::all() | wgpu::Backends::SECONDARY;
let instance = wgpu::Instance::new(descriptor);
let adapter = pollster_block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::default(),
force_fallback_adapter: false,
compatible_surface: None,
}))
.ok()?;
let device_result = pollster_block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("screen_frame_bus.wgpu_staging_backend.test_device"),
required_features: wgpu::Features::empty(),
required_limits: wgpu::Limits::default(),
memory_hints: wgpu::MemoryHints::default(),
trace: wgpu::Trace::Off,
experimental_features: wgpu::ExperimentalFeatures::default(),
}));
match device_result {
Ok((device, queue)) => Some((device, queue, instance)),
Err(_) => None,
}
}
fn pollster_block_on<F: core::future::Future>(fut: F) -> F::Output {
futures_executor_block_on(fut)
}
fn futures_executor_block_on<F: core::future::Future>(mut fut: F) -> F::Output {
use core::pin::Pin;
use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
fn raw_waker() -> RawWaker {
fn no_op(_: *const ()) {}
fn clone(_: *const ()) -> RawWaker {
raw_waker()
}
static VTABLE: RawWakerVTable = RawWakerVTable::new(clone, no_op, no_op, no_op);
RawWaker::new(core::ptr::null(), &VTABLE)
}
let waker = unsafe { Waker::from_raw(raw_waker()) };
let mut cx = Context::from_waker(&waker);
let mut fut = unsafe { Pin::new_unchecked(&mut fut) };
loop {
match fut.as_mut().poll(&mut cx) {
Poll::Ready(out) => return out,
Poll::Pending => continue,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{CpuStagingBackend, STAGING_PAIR_LEN, StagingSurfacePair};
use fluxer_gpu_rebuild::{GpuLossRegistry, RebuildOutcome};
struct GpuCtx {
device: wgpu::Device,
queue: wgpu::Queue,
_instance: wgpu::Instance,
}
fn gpu_ctx() -> Option<GpuCtx> {
let acquired = std::panic::catch_unwind(std::panic::AssertUnwindSafe(try_acquire_device));
let (device, queue, instance) = match acquired {
Ok(Some(triple)) => triple,
Ok(None) => return None,
Err(_) => return None,
};
Some(GpuCtx {
device,
queue,
_instance: instance,
})
}
#[test]
fn staging_backend_is_ready_only_when_built() {
let Some(ctx) = gpu_ctx() else {
eprintln!("screen-frame-bus gpu_loss: no wgpu adapter, skipping");
return;
};
let cfg = WgpuStagingConfig::new(256);
let mut backend = WgpuStagingBackend::new(&ctx.device, cfg);
assert!(
GpuLossCallback::is_ready(&backend),
"freshly built backend must be ready",
);
backend.release();
assert!(
!GpuLossCallback::is_ready(&backend),
"released backend must not be ready",
);
let outcome = backend.rebuild(&ctx.device, &ctx.queue);
assert!(outcome.is_ok(), "rebuild on fresh device must succeed");
assert!(
GpuLossCallback::is_ready(&backend),
"rebuilt backend must be ready",
);
}
#[test]
fn registry_handles_staging_backend_round_trip() {
let Some(ctx) = gpu_ctx() else {
eprintln!("screen-frame-bus gpu_loss: no wgpu adapter, skipping");
return;
};
let registry = GpuLossRegistry::new();
let backend = Box::new(WgpuStagingBackend::new(
&ctx.device,
WgpuStagingConfig::new(128),
));
let _guard = registry.register(backend);
let report = registry.handle_device_lost(&ctx.device, &ctx.queue);
assert_eq!(report.released_count, 1);
assert_eq!(report.rebuilt_count, 1);
assert_eq!(report.failed_count, 0);
assert!(report.is_total_success());
}
#[test]
fn double_rebuild_without_release_is_owner_invariant_error() {
let Some(ctx) = gpu_ctx() else {
eprintln!("screen-frame-bus gpu_loss: no wgpu adapter, skipping");
return;
};
let mut backend = WgpuStagingBackend::new(&ctx.device, WgpuStagingConfig::new(64));
let outcome = backend.rebuild(&ctx.device, &ctx.queue);
assert!(matches!(
outcome,
Err(GpuRebuildError::OwnerInvariantBroken { .. })
));
}
#[test]
fn write_between_release_and_rebuild_is_a_noop_and_not_ready() {
let Some(ctx) = gpu_ctx() else {
eprintln!("screen-frame-bus gpu_loss: no wgpu adapter, skipping");
return;
};
let mut backend = WgpuStagingBackend::new(&ctx.device, WgpuStagingConfig::new(64));
backend.release();
backend.write(|buf| buf.fill(0xAA));
assert!(
!<WgpuStagingBackend as StagingBackend>::is_ready(&backend),
"write before rebuild must not flip ready",
);
let observed = backend.read(|buf| buf.len());
assert_eq!(observed, 0, "read before rebuild must observe empty mirror");
}
#[test]
fn surface_pair_with_wgpu_backend_round_trips_cpu_mirror() {
let Some(ctx) = gpu_ctx() else {
eprintln!("screen-frame-bus gpu_loss: no wgpu adapter, skipping");
return;
};
let cfg = WgpuStagingConfig::new(64);
let a = WgpuStagingBackend::new(&ctx.device, cfg);
let b = WgpuStagingBackend::new(&ctx.device, cfg);
assert_eq!(
STAGING_PAIR_LEN, 2,
"OBS staging pair is exactly two surfaces"
);
let mut pair: StagingSurfacePair<WgpuStagingBackend> = StagingSurfacePair::new([a, b]);
pair.submit(0, |buf| {
buf[0] = 0xDE;
buf[1] = 0xAD;
})
.expect("submit zero must succeed");
pair.submit(1, |buf| {
buf[0] = 0xBE;
buf[1] = 0xEF;
})
.expect("submit one must succeed");
let first = pair
.try_map(0, |buf| (buf[0], buf[1]))
.expect("map zero ready");
assert_eq!(first, (0xDE, 0xAD));
let second = pair
.try_map(1, |buf| (buf[0], buf[1]))
.expect("map one ready");
assert_eq!(second, (0xBE, 0xEF));
}
#[test]
fn registry_holds_mixed_packers_and_staging_backends() {
let Some(ctx) = gpu_ctx() else {
eprintln!("screen-frame-bus gpu_loss: no wgpu adapter, skipping");
return;
};
let registry = GpuLossRegistry::new();
let mut guards = Vec::new();
for i in 0..4u32 {
let bytes = 32u64 << (i % 4);
let backend = Box::new(WgpuStagingBackend::new(
&ctx.device,
WgpuStagingConfig::new(bytes),
));
guards.push(registry.register(backend));
}
let report = registry.handle_device_lost(&ctx.device, &ctx.queue);
assert_eq!(report.released_count, 4);
assert_eq!(report.rebuilt_count, 4);
assert_eq!(report.failed_count, 0);
for outcome in &report.outcomes {
assert!(matches!(outcome, RebuildOutcome::Rebuilt { .. }));
}
drop(guards);
}
use super::StagingBackend;
use crate::CpuStagingBackend;
#[test]
fn cpu_backend_still_works_alongside_wgpu_backend() {
@@ -410,20 +204,4 @@ mod tests {
assert!(<CpuStagingBackend as StagingBackend>::is_idle(&cpu));
assert!(<CpuStagingBackend as StagingBackend>::is_ready(&cpu));
}
#[test]
fn buffer_handle_disappears_after_release_and_reappears_after_rebuild() {
let Some(ctx) = gpu_ctx() else {
eprintln!("screen-frame-bus gpu_loss: no wgpu adapter, skipping");
return;
};
let mut backend = WgpuStagingBackend::new(&ctx.device, WgpuStagingConfig::new(128));
assert!(backend.buffer().is_some(), "buffer present after build");
backend.release();
assert!(backend.buffer().is_none(), "buffer absent after release");
backend
.rebuild(&ctx.device, &ctx.queue)
.expect("rebuild must succeed");
assert!(backend.buffer().is_some(), "buffer present after rebuild");
}
}