lurq 0.41.2

A Rust UI toolkit with typed components, retained state, reactive signals, GPU rendering, and DevTools.
Documentation
use super::*;
fn canvas(software: bool) -> CanvasHandle {
  let c = CanvasHandle::new();
  let mut s = c.inner.lock();
  s.attached = true;
  s.software = software;
  s.metrics.pixel_width = 8;
  s.metrics.pixel_height = 8;
  s.metrics.size = Size::new(8., 8.);
  if software {
    s.pixels = Pixmap::new(8, 8);
  }
  drop(s);
  c
}
fn snapshot(c: &CanvasHandle) -> Vec<u8> {
  c.snapshot().try_take().unwrap().unwrap().rgba
}
#[test]
fn complete_front_survives_partial_recording_abort_and_superseded_commit() {
  let c = canvas(true);
  let d = c.context_2d();
  d.set_fill_style("#ff0000");
  d.fill_rect(0., 0., 8., 8.);
  let before = snapshot(&c);
  let first = d.begin_presentation().unwrap();
  d.reset();
  d.set_fill_style("#0000ff");
  d.fill_rect(0., 0., 4., 8.);
  assert_eq!(snapshot(&c), before);
  let latest = d.begin_presentation().unwrap();
  assert_eq!(d.commit_presentation(first), Err(CanvasError::StateLimit));
  d.abort_presentation(latest).unwrap();
  assert_eq!(snapshot(&c), before);
  let next = d.begin_presentation().unwrap();
  d.reset();
  d.set_fill_style("#00ff00");
  d.fill_rect(0., 0., 8., 8.);
  d.commit_presentation(next).unwrap();
  assert_ne!(snapshot(&c), before);
}
#[test]
fn artwork_excludes_later_overlay_and_camera_draw_never_reads_back() {
  let c = canvas(true);
  let d = c.context_2d();
  let token = d.begin_presentation().unwrap();
  d.reset();
  d.set_fill_style("#ff0000");
  d.fill_rect(0., 0., 8., 8.);
  d.capture_artwork().unwrap();
  d.set_fill_style("#0000ff");
  d.fill_rect(0., 0., 4., 8.);
  d.commit_presentation(token).unwrap();
  assert_eq!(&snapshot(&c)[..4], &[0, 0, 255, 255]);
  let token = d.begin_presentation().unwrap();
  d.reset();
  d.draw_retained_artwork(Transform2D::translate(2., 0.)).unwrap();
  d.commit_presentation(token).unwrap();
  let pixels = snapshot(&c);
  assert_eq!(&pixels[2 * 4..3 * 4], &[255, 0, 0, 255]);
  assert_eq!(&pixels[..4], &[0, 0, 0, 0]);
  d.forget_artwork();
  let token = d.begin_presentation().unwrap();
  assert_eq!(
    d.draw_retained_artwork(Transform2D::IDENTITY),
    Err(CanvasError::StateLimit)
  );
  d.abort_presentation(token).unwrap();
}
#[test]
fn reset_preserves_transaction_barriers_and_latest_camera_order() {
  let c = canvas(false);
  let d = c.context_2d();
  let first = d.begin_presentation().unwrap();
  d.fill_rect(0., 0., 8., 8.);
  d.capture_artwork().unwrap();
  d.commit_presentation(first).unwrap();
  let latest = d.begin_presentation().unwrap();
  d.reset();
  d.draw_retained_artwork(Transform2D::IDENTITY).unwrap();
  d.commit_presentation(latest).unwrap();
  let mut batch = c.take_batch().unwrap();
  let commands = batch.take_commands();
  let latest_begin = commands
    .iter()
    .position(|c| matches!(c,gpu::Command::BeginPresentation(t, _) if *t==latest))
    .unwrap();
  assert!(matches!(commands[latest_begin + 1], gpu::Command::Clear));
  assert!(matches!(commands[latest_begin + 2], gpu::Command::RetainedArtwork(_)));
  assert!(matches!(commands[latest_begin+3],gpu::Command::CommitPresentation(t, _) if t==latest));
  assert!(
    commands[..latest_begin]
      .iter()
      .any(|c| matches!(c,gpu::Command::BeginPresentation(t, _) if *t==first))
  );
  assert!(!c.presentation_current(first));
  assert!(c.presentation_current(latest));
  batch.submit();
}
#[test]
fn presentation_requires_balanced_layers_and_detach_releases_artwork() {
  let c = canvas(true);
  let d = c.context_2d();
  let token = d.begin_presentation().unwrap();
  d.begin_layer(1., BlendMode::Normal).unwrap();
  assert_eq!(d.commit_presentation(token), Err(CanvasError::UnbalancedLayer));
  d.abort_presentation(token).unwrap();
  assert!(c.inner.lock().software_layers.is_empty());
  let recovered = d.begin_presentation().unwrap();
  d.reset();
  d.set_fill_style("#00ff00");
  d.fill_rect(0., 0., 8., 8.);
  d.commit_presentation(recovered).unwrap();
  assert_eq!(&snapshot(&c)[..4], &[0, 255, 0, 255]);
  c.detach();
  assert!(c.inner.lock().artwork_pixels.is_none());
  assert!(!c.presentation_current(token));
}
#[test]
fn four_4k_targets_fit_the_separate_presentation_allowance_without_pixel_cap_widening() {
  assert!(presentation_admitted(3840 * 2160));
  assert_eq!(3840u64 * 2160 * 16, 132_710_400);
  assert!(!presentation_admitted(MAX_PIXELS));
  assert!(!presentation_admitted(MAX_PIXELS + 1));
  assert!(!presentation_admitted(0));
  assert!(!presentation_admitted(u64::MAX));
}

#[test]
fn pending_readback_keeps_complete_front_revision_and_refused_begin_keeps_current_token() {
  let c = canvas(true);
  let d = c.context_2d();
  d.set_fill_style("#ff0000");
  d.fill_rect(0., 0., 8., 8.);
  let before = c.snapshot().try_take().unwrap().unwrap();
  let token = d.begin_presentation().unwrap();
  d.reset();
  d.set_fill_style("#0000ff");
  d.fill_rect(0., 0., 8., 8.);
  let pending = c.snapshot().try_take().unwrap().unwrap();
  assert_eq!((pending.rgba, pending.revision), (before.rgba, before.revision));
  let serial = c.inner.lock().presentation_serial;
  {
    let mut s = c.inner.lock();
    s.metrics.pixel_width = u32::MAX;
  }
  assert_eq!(d.begin_presentation(), Err(CanvasError::SurfaceTooLarge));
  assert_eq!(c.inner.lock().presentation_serial, serial);
  assert!(c.presentation_current(token));
  d.abort_presentation(token).unwrap();
}