use std::{
collections::{BTreeMap, BTreeSet, HashMap},
error::Error,
fmt,
};
use whisker_layout::{
IntrinsicMeasurer, IntrinsicResult, LayoutSize, MeasureRequest as LayoutMeasureRequest,
MeasuredInlineChild, MeasurementState,
};
use whisker_protocol::{
AvailableSpace, ElementTypeId, MeasureConstraints, MeasuredSize, MeasurementKey,
MeasurementKind, MeasurementMetrics, MeasurementPayload, MeasurementPayloadError,
MeasurementReady, MeasurementRequest, MeasurementRequestId, MeasurementResponse,
MeasurementSpec, NodeId, PendingMeasurePolicy, UnsupportedMeasurementReason,
};
use crate::LayoutUpdate;
#[derive(Clone, Debug, PartialEq)]
pub enum LayoutProgress {
Complete(LayoutUpdate),
Provisional {
update: LayoutUpdate,
requests: Vec<MeasurementRequest>,
pending: usize,
},
Blocked {
requests: Vec<MeasurementRequest>,
pending: usize,
},
}
impl LayoutProgress {
pub fn requests(&self) -> &[MeasurementRequest] {
match self {
Self::Complete(_) => &[],
Self::Provisional { requests, .. } | Self::Blocked { requests, .. } => requests,
}
}
pub const fn has_layout(&self) -> bool {
matches!(self, Self::Complete(_) | Self::Provisional { .. })
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct MeasurementApply {
applied: usize,
stale: usize,
invalidated_nodes: Vec<NodeId>,
}
impl MeasurementApply {
pub const fn applied(&self) -> usize {
self.applied
}
pub const fn stale(&self) -> usize {
self.stale
}
pub(crate) fn invalidated_nodes(&self) -> &[NodeId] {
&self.invalidated_nodes
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum DeferredMeasurementApply {
Applied {
invalidated_nodes: Vec<NodeId>,
},
IgnoredStale,
Queued,
}
impl DeferredMeasurementApply {
pub(crate) fn invalidated_nodes(&self) -> &[NodeId] {
match self {
Self::Applied { invalidated_nodes } => invalidated_nodes,
Self::IgnoredStale | Self::Queued => &[],
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum MeasurementError {
InvalidPayload {
node: NodeId,
error: MeasurementPayloadError,
},
InvalidPlaceholder {
node: NodeId,
},
InvalidMetrics {
key: MeasurementKey,
},
DuplicateRequestId {
request_id: MeasurementRequestId,
},
MissingSpec {
node: NodeId,
},
Unsupported {
node: NodeId,
reason: UnsupportedMeasurementReason,
},
KeyExhausted,
}
impl fmt::Display for MeasurementError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "Whisker measurement error: {self:?}")
}
}
impl Error for MeasurementError {}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum AvailableSpaceKey {
Definite(u32),
MinContent,
MaxContent,
}
impl From<AvailableSpace> for AvailableSpaceKey {
fn from(value: AvailableSpace) -> Self {
match value {
AvailableSpace::Definite(value) => Self::Definite(value.to_bits()),
AvailableSpace::MinContent => Self::MinContent,
AvailableSpace::MaxContent => Self::MaxContent,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
struct ConstraintsKey {
known_dimensions: [Option<u32>; 2],
available_space: [AvailableSpaceKey; 2],
}
impl From<MeasureConstraints> for ConstraintsKey {
fn from(value: MeasureConstraints) -> Self {
Self {
known_dimensions: value
.known_dimensions
.map(|dimension| dimension.map(f32::to_bits)),
available_space: value.available_space.map(Into::into),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
struct CacheKey {
element_type: ElementTypeId,
kind: MeasurementKind,
content_hash: u64,
style_hash: u64,
environment_epoch: u64,
constraints: ConstraintsKey,
inline_children: Vec<(NodeId, u32, u32, u32)>,
paragraph_node: Option<NodeId>,
}
#[derive(Clone, Debug)]
struct SpecState {
element_type: ElementTypeId,
spec: MeasurementSpec,
last_ready: Option<MeasurementMetrics>,
attachments: Vec<crate::InlineAttachmentInput>,
}
#[derive(Clone, Debug)]
enum CachedState {
Ready(MeasurementMetrics),
Pending {
key: MeasurementKey,
request_id: MeasurementRequestId,
provisional: Option<MeasurementMetrics>,
},
Unsupported(UnsupportedMeasurementReason),
}
#[derive(Clone, Debug)]
struct CacheEntry {
key: MeasurementKey,
payload: MeasurementPayload,
state: CachedState,
consumers: BTreeSet<NodeId>,
}
#[derive(Clone, Debug)]
struct OutstandingRequest {
request: MeasurementRequest,
cache_key: CacheKey,
consumers: BTreeSet<NodeId>,
}
#[derive(Clone, Debug)]
struct PendingRequest {
key: MeasurementKey,
cache_key: CacheKey,
environment_epoch: u64,
}
#[derive(Clone, Debug, Default)]
struct PassState {
requests: BTreeMap<MeasurementKey, MeasurementRequest>,
pending: BTreeSet<MeasurementRequestId>,
blocking: bool,
provisional: bool,
error: Option<MeasurementError>,
}
#[derive(Clone, Debug)]
pub(crate) struct MeasurementCoordinator {
specs: BTreeMap<NodeId, SpecState>,
cache: HashMap<CacheKey, CacheEntry>,
consumer_keys: HashMap<NodeId, Vec<CacheKey>>,
outstanding: BTreeMap<MeasurementKey, OutstandingRequest>,
outstanding_by_cache: HashMap<CacheKey, MeasurementKey>,
pending: BTreeMap<MeasurementRequestId, PendingRequest>,
environment_epoch: Option<u64>,
next_key: u64,
retention_revision: u64,
pass: PassState,
}
impl Default for MeasurementCoordinator {
fn default() -> Self {
Self {
specs: BTreeMap::new(),
cache: HashMap::new(),
consumer_keys: HashMap::new(),
outstanding: BTreeMap::new(),
outstanding_by_cache: HashMap::new(),
pending: BTreeMap::new(),
environment_epoch: None,
next_key: 1,
retention_revision: 0,
pass: PassState::default(),
}
}
}
impl MeasurementCoordinator {
pub(crate) fn set_environment(&mut self, epoch: u64) -> Vec<NodeId> {
let changed = self
.environment_epoch
.is_some_and(|current| current != epoch);
self.environment_epoch = Some(epoch);
if !changed {
return Vec::new();
}
self.retention_revision = self.retention_revision.wrapping_add(1);
self.cache.clear();
self.consumer_keys.clear();
self.outstanding.clear();
self.outstanding_by_cache.clear();
self.pending.clear();
self.specs.keys().copied().collect()
}
pub(crate) fn retained_content(
&self,
) -> (
u64,
impl Iterator<Item = whisker_protocol::PreparedContentId> + '_,
) {
let cached = self.cache.values().filter_map(|entry| match &entry.state {
CachedState::Ready(metrics) => metrics.prepared_content,
CachedState::Pending { provisional, .. } => provisional
.as_ref()
.and_then(|metrics| metrics.prepared_content),
CachedState::Unsupported(_) => None,
});
let provisional = self.specs.values().filter_map(|state| {
state
.last_ready
.as_ref()
.and_then(|metrics| metrics.prepared_content)
});
(self.retention_revision, cached.chain(provisional))
}
pub(crate) fn environment_epoch(&self) -> Option<u64> {
self.environment_epoch
}
pub(crate) fn matches_spec(
&self,
node: NodeId,
element_type: ElementTypeId,
spec: Option<&MeasurementSpec>,
) -> bool {
self.specs
.get(&node)
.map(|state| (state.element_type, &state.spec))
== spec.map(|spec| (element_type, spec))
}
pub(crate) fn set_spec(
&mut self,
node: NodeId,
element_type: ElementTypeId,
spec: Option<MeasurementSpec>,
) -> Result<bool, MeasurementError> {
if let Some(spec) = &spec {
spec.payload
.validate()
.map_err(|error| MeasurementError::InvalidPayload { node, error })?;
}
if let Some(MeasurementSpec {
pending_policy: PendingMeasurePolicy::Placeholder(size),
..
}) = &spec
&& !size.is_valid()
{
return Err(MeasurementError::InvalidPlaceholder { node });
}
if self.matches_spec(node, element_type, spec.as_ref()) {
return Ok(false);
}
self.retention_revision = self.retention_revision.wrapping_add(1);
self.remove_consumer(node);
let previous = self.specs.remove(&node).and_then(|state| state.last_ready);
if let Some(spec) = spec {
self.specs.insert(
node,
SpecState {
element_type,
spec,
last_ready: previous,
attachments: Vec::new(),
},
);
}
Ok(true)
}
pub(crate) fn remove_node(&mut self, node: NodeId) {
self.retention_revision = self.retention_revision.wrapping_add(1);
self.remove_consumer(node);
self.specs.remove(&node);
}
pub(crate) fn last_ready(&self, node: NodeId) -> Option<&MeasurementMetrics> {
self.specs.get(&node)?.last_ready.as_ref()
}
pub(crate) fn inline_attachments_match(
&self,
node: NodeId,
attachments: &[crate::InlineAttachmentInput],
) -> bool {
self.specs
.get(&node)
.is_some_and(|state| state.attachments == attachments)
}
pub(crate) fn set_inline_attachments(
&mut self,
node: NodeId,
attachments: &[crate::InlineAttachmentInput],
) {
self.specs
.get_mut(&node)
.expect("paragraph measurement spec")
.attachments = attachments.to_vec();
}
pub(crate) fn outstanding_requests(&self) -> Vec<MeasurementRequest> {
self.outstanding
.values()
.filter(|request| !request.consumers.is_empty())
.map(|request| request.request.clone())
.collect()
}
pub(crate) fn pending_count(&self) -> usize {
self.cache
.values()
.filter(|entry| {
!entry.consumers.is_empty() && matches!(entry.state, CachedState::Pending { .. })
})
.count()
}
pub(crate) fn unresolved_nodes(&self) -> Vec<NodeId> {
let mut nodes = BTreeSet::new();
for request in self.outstanding.values() {
nodes.extend(&request.consumers);
}
for entry in self.cache.values() {
if matches!(entry.state, CachedState::Pending { .. }) {
nodes.extend(&entry.consumers);
}
}
nodes.into_iter().collect()
}
pub(crate) fn begin_pass(&mut self) {
self.pass = PassState::default();
}
pub(crate) fn finish_pass(&mut self) -> Result<PassSummary, MeasurementError> {
if let Some(error) = self.pass.error.take() {
return Err(error);
}
Ok(PassSummary {
requests: std::mem::take(&mut self.pass.requests)
.into_values()
.collect(),
pending: self.pass.pending.len(),
blocking: self.pass.blocking,
provisional: self.pass.provisional,
})
}
pub(crate) fn apply_batch(
&mut self,
responses: &[MeasurementResponse],
) -> Result<MeasurementApply, MeasurementError> {
let mut consumed = BTreeSet::new();
let mut pending_ids = BTreeSet::new();
let mut validated = Vec::with_capacity(responses.len());
let mut apply = MeasurementApply::default();
for response in responses {
let key = response.key();
let current = self.outstanding.get(&key).is_some_and(|outstanding| {
outstanding.request.environment_epoch == response.environment_epoch()
&& self.environment_epoch == Some(response.environment_epoch())
});
if !current || !consumed.insert(key) {
apply.stale += 1;
continue;
}
match response {
MeasurementResponse::Ready { metrics, .. } => {
self.validate_metrics(key, metrics)?
}
MeasurementResponse::Pending {
request_id,
provisional,
..
} => {
if self.pending.contains_key(request_id) || !pending_ids.insert(*request_id) {
return Err(MeasurementError::DuplicateRequestId {
request_id: *request_id,
});
}
if let Some(metrics) = provisional {
self.validate_metrics(key, metrics)?;
}
}
MeasurementResponse::Unsupported { .. } => {}
}
validated.push(response);
}
if !validated.is_empty() {
self.retention_revision = self.retention_revision.wrapping_add(1);
}
let mut invalidated = BTreeSet::new();
for response in validated {
self.commit_response(response, &mut invalidated);
apply.applied += 1;
}
apply.invalidated_nodes = invalidated.into_iter().collect();
Ok(apply)
}
pub(crate) fn apply_ready(
&mut self,
ready: &MeasurementReady,
) -> Result<DeferredMeasurementApply, MeasurementError> {
self.retention_revision = self.retention_revision.wrapping_add(1);
let Some(pending) = self.pending.get(&ready.request_id).cloned() else {
return Ok(DeferredMeasurementApply::IgnoredStale);
};
if pending.key != ready.key
|| pending.environment_epoch != ready.environment_epoch
|| self.environment_epoch != Some(ready.environment_epoch)
{
return Ok(DeferredMeasurementApply::IgnoredStale);
}
if self
.cache
.get(&pending.cache_key)
.is_some_and(|entry| !ready.metrics.matches_payload(&entry.payload))
{
return Err(MeasurementError::InvalidMetrics { key: ready.key });
}
let Some(entry) = self.cache.get_mut(&pending.cache_key) else {
return Ok(DeferredMeasurementApply::IgnoredStale);
};
if !matches!(
entry.state,
CachedState::Pending {
key,
request_id,
..
} if key == ready.key && request_id == ready.request_id
) {
return Ok(DeferredMeasurementApply::IgnoredStale);
}
let consumers = entry.consumers.clone();
entry.state = CachedState::Ready(ready.metrics.clone());
self.pending.remove(&ready.request_id);
self.remember_ready(&consumers, &ready.metrics);
Ok(DeferredMeasurementApply::Applied {
invalidated_nodes: consumers.into_iter().collect(),
})
}
fn commit_response(
&mut self,
response: &MeasurementResponse,
invalidated: &mut BTreeSet<NodeId>,
) {
let key = response.key();
let outstanding = self
.outstanding
.remove(&key)
.expect("validated responses consume each outstanding request once");
self.outstanding_by_cache.remove(&outstanding.cache_key);
invalidated.extend(&outstanding.consumers);
let state = match response {
MeasurementResponse::Ready { metrics, .. } => {
self.remember_ready(&outstanding.consumers, metrics);
CachedState::Ready(metrics.clone())
}
MeasurementResponse::Pending {
request_id,
provisional,
..
} => {
self.pending.insert(
*request_id,
PendingRequest {
key,
cache_key: outstanding.cache_key.clone(),
environment_epoch: response.environment_epoch(),
},
);
CachedState::Pending {
key,
request_id: *request_id,
provisional: provisional.clone(),
}
}
MeasurementResponse::Unsupported { reason, .. } => CachedState::Unsupported(*reason),
};
self.cache.insert(
outstanding.cache_key,
CacheEntry {
key,
payload: outstanding.request.payload,
state,
consumers: outstanding.consumers,
},
);
}
fn validate_metrics(
&self,
key: MeasurementKey,
metrics: &MeasurementMetrics,
) -> Result<(), MeasurementError> {
if self
.outstanding
.get(&key)
.is_some_and(|request| metrics.matches_payload(&request.request.payload))
{
Ok(())
} else {
Err(MeasurementError::InvalidMetrics { key })
}
}
fn remember_ready(&mut self, consumers: &BTreeSet<NodeId>, metrics: &MeasurementMetrics) {
for node in consumers {
self.specs
.get_mut(node)
.expect("measurement consumers retain their registered specs")
.last_ready = Some(metrics.clone());
}
}
fn remove_consumer(&mut self, node: NodeId) {
let Some(cache_keys) = self.consumer_keys.remove(&node) else {
return;
};
for cache_key in cache_keys {
let remove_cached = self.cache.get_mut(&cache_key).is_some_and(|entry| {
entry.consumers.remove(&node);
entry.consumers.is_empty()
});
if remove_cached {
let entry = self
.cache
.remove(&cache_key)
.expect("checked cache entry remains present");
if let CachedState::Pending { request_id, .. } = entry.state {
self.pending.remove(&request_id);
}
continue;
}
let Some(key) = self.outstanding_by_cache.get(&cache_key).copied() else {
continue;
};
let remove_outstanding = self.outstanding.get_mut(&key).is_some_and(|request| {
request.consumers.remove(&node);
request.consumers.is_empty()
});
if remove_outstanding {
self.outstanding.remove(&key);
self.outstanding_by_cache.remove(&cache_key);
}
}
}
fn remember_consumer(&mut self, node: NodeId, cache_key: CacheKey) {
self.consumer_keys.entry(node).or_default().push(cache_key);
}
fn cache_key(state: &SpecState, constraints: MeasureConstraints, epoch: u64) -> CacheKey {
CacheKey {
element_type: state.element_type,
kind: state.spec.payload.kind(),
content_hash: state.spec.content_hash,
style_hash: state.spec.style_hash,
environment_epoch: epoch,
constraints: constraints.into(),
inline_children: Vec::new(),
paragraph_node: None,
}
}
fn use_fallback(
&mut self,
policy: PendingMeasurePolicy,
last_ready: Option<&MeasurementMetrics>,
provider_provisional: Option<&MeasurementMetrics>,
) -> LayoutSize {
if let Some(metrics) = provider_provisional {
self.pass.provisional = true;
return to_layout_size(metrics.size);
}
match policy {
PendingMeasurePolicy::Block => {
self.pass.blocking = true;
LayoutSize::default()
}
PendingMeasurePolicy::Placeholder(size) => {
self.pass.provisional = true;
to_layout_size(size)
}
PendingMeasurePolicy::RetainPrevious => {
if let Some(metrics) = last_ready {
self.pass.provisional = true;
to_layout_size(metrics.size)
} else {
self.pass.blocking = true;
LayoutSize::default()
}
}
}
}
fn allocate_key(&mut self) -> Result<MeasurementKey, MeasurementError> {
let key = MeasurementKey::new(self.next_key).ok_or(MeasurementError::KeyExhausted)?;
self.next_key = self.next_key.checked_add(1).unwrap_or(0);
Ok(key)
}
}
impl MeasurementCoordinator {
fn resolve_intrinsic(
&mut self,
node: NodeId,
constraints: LayoutMeasureRequest,
children: &[MeasuredInlineChild],
) -> IntrinsicResult {
let Some(mut state) = self.specs.get(&node).cloned() else {
self.pass
.error
.get_or_insert(MeasurementError::MissingSpec { node });
return IntrinsicResult {
state: MeasurementState::Blocked,
..IntrinsicResult::default()
};
};
if let MeasurementPayload::Text(payload) = &mut state.spec.payload {
if !state.attachments.is_empty() {
if state.attachments.len() != children.len()
|| state.attachments.iter().any(|attachment| {
!children.iter().any(|child| child.node == attachment.node)
})
{
self.pass
.error
.get_or_insert(MeasurementError::MissingSpec { node });
return IntrinsicResult {
state: MeasurementState::Blocked,
..IntrinsicResult::default()
};
}
payload.attachments = state
.attachments
.iter()
.map(|attachment| {
let child = children
.iter()
.find(|child| child.node == attachment.node)
.expect("validated inline subtree");
whisker_protocol::InlineAttachment {
truncation: attachment.truncation,
label: attachment.label.clone(),
node: attachment.node,
range: attachment.range,
alignment: attachment.alignment,
size: MeasuredSize::new(child.size.width, child.size.height),
baseline: child.baseline,
}
})
.collect();
}
}
let constraints = if state.spec.payload.kind() == MeasurementKind::Text {
MeasureConstraints {
available_space: [constraints.available_space[0], AvailableSpace::MaxContent],
..constraints
}
} else {
constraints
};
let epoch = self.environment_epoch.unwrap_or(0);
let mut cache_key = Self::cache_key(&state, constraints, epoch);
if matches!(&state.spec.payload, MeasurementPayload::Text(text) if !text.runs.is_empty() || !text.attachments.is_empty())
{
cache_key.paragraph_node = Some(node);
}
cache_key.inline_children = children
.iter()
.map(|child| {
(
child.node,
child.size.width.to_bits(),
child.size.height.to_bits(),
child.baseline.to_bits(),
)
})
.collect();
if let Some(entry) = self.cache.get_mut(&cache_key) {
let added = entry.consumers.insert(node);
let cached = entry.state.clone();
let selection = entry.key;
if added {
self.remember_consumer(node, cache_key);
}
return match cached {
CachedState::Ready(metrics) => {
self.specs
.get_mut(&node)
.expect("measurement node retains its registered spec")
.last_ready = Some(metrics.clone());
IntrinsicResult {
size: to_layout_size(metrics.size),
first_baseline: metrics.first_baseline,
state: MeasurementState::Ready,
selection: Some(selection),
inline_placements: metrics.inline_placements,
}
}
CachedState::Pending {
request_id,
provisional,
..
} => {
self.pass.pending.insert(request_id);
self.fallback_result(
state.spec.pending_policy,
state.last_ready.as_ref(),
provisional.as_ref(),
)
}
CachedState::Unsupported(reason) => {
self.pass
.error
.get_or_insert(MeasurementError::Unsupported { node, reason });
IntrinsicResult {
state: MeasurementState::Blocked,
..IntrinsicResult::default()
}
}
};
}
if let Some(key) = self.outstanding_by_cache.get(&cache_key).copied() {
let request = self
.outstanding
.get_mut(&key)
.expect("cache index points to an outstanding request");
let added = request.consumers.insert(node);
self.pass.requests.insert(key, request.request.clone());
if added {
self.remember_consumer(node, cache_key);
}
return self.fallback_result(
state.spec.pending_policy,
state.last_ready.as_ref(),
None,
);
}
let key = match self.allocate_key() {
Ok(key) => key,
Err(error) => {
self.pass.error.get_or_insert(error);
return IntrinsicResult {
state: MeasurementState::Blocked,
..IntrinsicResult::default()
};
}
};
let request = MeasurementRequest {
key,
node,
element_type: state.element_type,
environment_epoch: epoch,
constraints,
payload: state.spec.payload.clone(),
};
self.outstanding_by_cache.insert(cache_key.clone(), key);
self.outstanding.insert(
key,
OutstandingRequest {
request: request.clone(),
cache_key: cache_key.clone(),
consumers: BTreeSet::from([node]),
},
);
self.remember_consumer(node, cache_key);
self.pass.requests.insert(key, request);
self.fallback_result(state.spec.pending_policy, state.last_ready.as_ref(), None)
}
}
impl IntrinsicMeasurer for MeasurementCoordinator {
fn measure(&mut self, node: NodeId, request: LayoutMeasureRequest) -> LayoutSize {
self.resolve_intrinsic(node, request, &[]).size
}
fn measure_detailed(&mut self, node: NodeId, request: LayoutMeasureRequest) -> IntrinsicResult {
self.resolve_intrinsic(node, request, &[])
}
fn measure_paragraph(
&mut self,
node: NodeId,
request: LayoutMeasureRequest,
children: &[MeasuredInlineChild],
) -> IntrinsicResult {
self.resolve_intrinsic(node, request, children)
}
}
impl MeasurementCoordinator {
pub(crate) fn selected(
&self,
node: NodeId,
selection: MeasurementKey,
) -> Option<(&MeasurementPayload, &MeasurementMetrics)> {
self.consumer_keys.get(&node)?.iter().find_map(|key| {
let entry = self.cache.get(key).expect("retained measurement consumer");
if entry.key != selection {
return None;
}
match &entry.state {
CachedState::Ready(metrics) => Some((&entry.payload, metrics)),
_ => None,
}
})
}
fn fallback_result(
&mut self,
policy: PendingMeasurePolicy,
previous: Option<&MeasurementMetrics>,
provisional: Option<&MeasurementMetrics>,
) -> IntrinsicResult {
let size = self.use_fallback(policy, previous, provisional);
let metrics = provisional.or_else(|| {
(policy == PendingMeasurePolicy::RetainPrevious)
.then_some(previous)
.flatten()
});
let ready_fallback = provisional.is_some()
|| matches!(policy, PendingMeasurePolicy::Placeholder(_))
|| (policy == PendingMeasurePolicy::RetainPrevious && previous.is_some());
IntrinsicResult {
size,
first_baseline: metrics.and_then(|metrics| metrics.first_baseline),
state: if ready_fallback {
MeasurementState::Provisional
} else {
MeasurementState::Blocked
},
selection: None,
inline_placements: metrics
.map_or_else(Vec::new, |metrics| metrics.inline_placements.clone()),
}
}
}
fn to_layout_size(value: MeasuredSize) -> LayoutSize {
LayoutSize::new(value.width, value.height)
}
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct PassSummary {
pub(crate) requests: Vec<MeasurementRequest>,
pub(crate) pending: usize,
pub(crate) blocking: bool,
pub(crate) provisional: bool,
}
#[cfg(test)]
mod tests {
use whisker_protocol::{
CustomMeasurePayload, EmbeddedSurfaceMeasurePayload, LayoutRect, MeasureFontFamily,
MeasureFontStyle, MeasureLineHeight, MeasureTextDirection, MeasureTextOverflow,
MeasureTextWrap, MeasurementPayload, NativeControlMeasurePayload, PreparedContentId,
ReplacedContentMeasurePayload, SurfaceId, TextMeasurePayload, TextMeasureStyle,
};
use super::*;
fn node(value: u64) -> NodeId {
NodeId::new(value).expect("node")
}
fn element() -> ElementTypeId {
ElementTypeId::new(1).expect("element")
}
fn constraints(width: f32) -> MeasureConstraints {
MeasureConstraints {
known_dimensions: [None, Some(10.0)],
available_space: [AvailableSpace::Definite(width), AvailableSpace::MaxContent],
}
}
fn spec(kind: MeasurementKind, policy: PendingMeasurePolicy) -> MeasurementSpec {
MeasurementSpec {
content_hash: 7,
style_hash: 9,
payload: payload(kind),
pending_policy: policy,
}
}
fn payload(kind: MeasurementKind) -> MeasurementPayload {
match kind {
MeasurementKind::Text => MeasurementPayload::Text(TextMeasurePayload {
runs: Vec::new(),
attachments: Vec::new(),
text: "payload".into(),
style: TextMeasureStyle {
font_families: vec![MeasureFontFamily::System],
font_size: 14.0,
font_weight: 400,
font_style: MeasureFontStyle::Normal,
line_height: MeasureLineHeight::Normal,
letter_spacing: 0.0,
..TextMeasureStyle::default()
},
locale: None,
direction: MeasureTextDirection::Auto,
alignment: whisker_protocol::MeasureTextAlignment::Start,
indent: Default::default(),
wrap: MeasureTextWrap::Wrap,
word_break: Default::default(),
max_lines: None,
overflow: MeasureTextOverflow::Clip,
}),
MeasurementKind::ReplacedContent => {
MeasurementPayload::ReplacedContent(ReplacedContentMeasurePayload::default())
}
MeasurementKind::NativeControl => {
MeasurementPayload::NativeControl(NativeControlMeasurePayload {
control_type: 1,
version: 1,
state: vec![1],
})
}
MeasurementKind::EmbeddedSurface => {
MeasurementPayload::EmbeddedSurface(EmbeddedSurfaceMeasurePayload {
surface: SurfaceId::new(2).expect("child surface"),
preferred_size: None,
})
}
MeasurementKind::Custom { version } => {
MeasurementPayload::Custom(CustomMeasurePayload {
version,
data: whisker_protocol::WhiskerValue::Bytes(b"payload".to_vec()),
})
}
}
}
fn metrics(width: f32, height: f32) -> MeasurementMetrics {
MeasurementMetrics {
paragraph: None,
inline_placements: Vec::new(),
size: MeasuredSize::new(width, height),
first_baseline: Some(6.0),
last_baseline: Some(7.0),
overflow: Some(LayoutRect {
width,
height,
..LayoutRect::default()
}),
prepared_content: PreparedContentId::new(3),
}
}
#[test]
fn text_measurement_shares_intrinsic_height_constraints() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
let node = NodeId::new(1).unwrap();
coordinator
.set_spec(
node,
ElementTypeId::new(1).unwrap(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
coordinator.begin_pass();
for height in [
AvailableSpace::MinContent,
AvailableSpace::MaxContent,
AvailableSpace::Definite(16.0),
AvailableSpace::Definite(20.0),
] {
coordinator.measure(
node,
MeasureConstraints {
known_dimensions: [Some(100.0), None],
available_space: [AvailableSpace::Definite(100.0), height],
},
);
}
let pass = coordinator.finish_pass().unwrap();
assert_eq!(pass.requests.len(), 1);
assert_eq!(
pass.requests[0].constraints.available_space[1],
AvailableSpace::MaxContent
);
}
#[test]
fn text_height_reuse_preserves_width_known_height_and_other_measurement_kinds() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
for (index, kind) in [
MeasurementKind::Text,
MeasurementKind::ReplacedContent,
MeasurementKind::NativeControl,
MeasurementKind::EmbeddedSurface,
MeasurementKind::Custom { version: 1 },
]
.into_iter()
.enumerate()
{
let node = node(index as u64 + 1);
coordinator
.set_spec(
node,
element(),
Some(spec(kind, PendingMeasurePolicy::Block)),
)
.unwrap();
coordinator.begin_pass();
for width in [100.0, 101.0] {
for known_height in [None, Some(20.0)] {
for height in [AvailableSpace::MaxContent, AvailableSpace::Definite(16.0)] {
coordinator.measure(
node,
MeasureConstraints {
known_dimensions: [Some(width), known_height],
available_space: [AvailableSpace::Definite(width), height],
},
);
}
}
}
let pass = coordinator.finish_pass().unwrap();
assert_eq!(
pass.requests.len(),
if kind == MeasurementKind::Text { 4 } else { 8 }
);
let responses = pass
.requests
.iter()
.map(|request| MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: metrics(100.0, 20.0),
})
.collect::<Vec<_>>();
coordinator.apply_batch(&responses).unwrap();
coordinator.begin_pass();
let size = coordinator.measure(
node,
MeasureConstraints {
known_dimensions: [Some(100.0), None],
available_space: [
AvailableSpace::Definite(100.0),
AvailableSpace::Definite(16.0),
],
},
);
assert_eq!(size, LayoutSize::new(100.0, 20.0));
assert!(coordinator.finish_pass().unwrap().requests.is_empty());
}
}
#[test]
fn rich_preparations_are_isolated_per_node_and_reused_for_each_consumer() {
for rich in [false, true] {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
let mut value = spec(MeasurementKind::Text, PendingMeasurePolicy::Block);
if rich && let MeasurementPayload::Text(text) = &mut value.payload {
text.runs.push(whisker_protocol::TextMeasureRun {
range: whisker_protocol::TextByteRange {
start: 0,
end: text.text.len() as u32,
},
style: text.style.clone(),
alignment: whisker_protocol::InlineAlignment::Baseline,
});
}
for id in [1, 2] {
coordinator
.set_spec(node(id), element(), Some(value.clone()))
.unwrap();
}
coordinator.begin_pass();
for id in [1, 2] {
coordinator.measure(node(id), constraints(100.0));
}
let pass = coordinator.finish_pass().unwrap();
assert_eq!(pass.requests.len(), if rich { 2 } else { 1 });
for request in pass.requests {
coordinator
.apply_batch(&[MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: metrics(20.0, 10.0),
}])
.unwrap();
}
coordinator.begin_pass();
for id in [1, 2] {
assert_eq!(
coordinator.measure(node(id), constraints(100.0)),
LayoutSize::new(20.0, 10.0)
);
}
assert!(coordinator.finish_pass().unwrap().requests.is_empty());
}
}
#[test]
fn coordinator_deduplicates_caches_and_invalidates_environment() {
let mut coordinator = MeasurementCoordinator::default();
assert!(coordinator.set_environment(1).is_empty());
assert!(coordinator.set_environment(1).is_empty());
assert!(
coordinator
.set_spec(
node(1),
element(),
Some(spec(
MeasurementKind::Text,
PendingMeasurePolicy::Placeholder(MeasuredSize::new(2.0, 3.0)),
)),
)
.unwrap()
);
assert!(
!coordinator
.set_spec(
node(1),
element(),
Some(spec(
MeasurementKind::Text,
PendingMeasurePolicy::Placeholder(MeasuredSize::new(2.0, 3.0)),
)),
)
.unwrap()
);
coordinator
.set_spec(
node(2),
element(),
Some(spec(
MeasurementKind::Text,
PendingMeasurePolicy::Placeholder(MeasuredSize::new(2.0, 3.0)),
)),
)
.unwrap();
coordinator.begin_pass();
assert_eq!(
coordinator.measure(node(1), constraints(100.0)),
LayoutSize::new(2.0, 3.0)
);
assert_eq!(
coordinator.measure(node(2), constraints(100.0)),
LayoutSize::new(2.0, 3.0)
);
let pass = coordinator.finish_pass().unwrap();
assert_eq!(pass.requests.len(), 1);
assert!(pass.provisional);
assert!(!pass.blocking);
let request = pass.requests[0].clone();
let apply = coordinator
.apply_batch(&[MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: metrics(20.0, 10.0),
}])
.unwrap();
assert_eq!(apply.applied(), 1);
assert_eq!(apply.stale(), 0);
assert_eq!(apply.invalidated_nodes(), [node(1), node(2)]);
coordinator.begin_pass();
assert_eq!(
coordinator.measure(node(1), constraints(100.0)),
LayoutSize::new(20.0, 10.0)
);
let pass = coordinator.finish_pass().unwrap();
assert!(pass.requests.is_empty());
assert!(!pass.provisional);
assert_eq!(coordinator.last_ready(node(1)), Some(&metrics(20.0, 10.0)));
assert_eq!(coordinator.pending_count(), 0);
assert_eq!(coordinator.set_environment(2), [node(1), node(2)]);
coordinator.begin_pass();
coordinator.measure(node(1), constraints(100.0));
assert_eq!(coordinator.finish_pass().unwrap().requests.len(), 1);
}
#[test]
fn pending_completion_rejects_stale_and_validates_metrics() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(4);
coordinator
.set_spec(
node(1),
element(),
Some(spec(
MeasurementKind::ReplacedContent,
PendingMeasurePolicy::Block,
)),
)
.unwrap();
coordinator.begin_pass();
assert_eq!(
coordinator.measure(node(1), constraints(80.0)),
LayoutSize::default()
);
let pass = coordinator.finish_pass().unwrap();
assert!(pass.blocking);
let key = pass.requests[0].key;
let request_id = MeasurementRequestId::new(11).expect("request");
let apply = coordinator
.apply_batch(&[MeasurementResponse::Pending {
key,
environment_epoch: 4,
request_id,
provisional: Some(metrics(8.0, 6.0)),
}])
.unwrap();
assert_eq!(apply.applied(), 1);
coordinator.begin_pass();
assert_eq!(
coordinator.measure(node(1), constraints(80.0)),
LayoutSize::new(8.0, 6.0)
);
let pass = coordinator.finish_pass().unwrap();
assert_eq!(pass.pending, 1);
assert!(pass.provisional);
let wrong = MeasurementReady {
key,
request_id,
environment_epoch: 5,
metrics: metrics(9.0, 7.0),
};
assert_eq!(
coordinator.apply_ready(&wrong).unwrap(),
DeferredMeasurementApply::IgnoredStale
);
let invalid = MeasurementReady {
environment_epoch: 4,
metrics: MeasurementMetrics::from_size(MeasuredSize::new(f32::NAN, 1.0)),
..wrong.clone()
};
assert_eq!(
coordinator.apply_ready(&invalid),
Err(MeasurementError::InvalidMetrics { key })
);
let ready = MeasurementReady {
environment_epoch: 4,
metrics: metrics(9.0, 7.0),
..wrong
};
assert_eq!(
coordinator.apply_ready(&ready).unwrap(),
DeferredMeasurementApply::Applied {
invalidated_nodes: vec![node(1)]
}
);
assert_eq!(
coordinator.apply_ready(&ready).unwrap(),
DeferredMeasurementApply::IgnoredStale
);
}
#[test]
fn policies_errors_and_stale_batches_are_explicit() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
let mut invalid_payload = spec(MeasurementKind::NativeControl, PendingMeasurePolicy::Block);
invalid_payload.payload = MeasurementPayload::NativeControl(NativeControlMeasurePayload {
control_type: 1,
version: 0,
state: Vec::new(),
});
assert_eq!(
coordinator.set_spec(node(1), element(), Some(invalid_payload)),
Err(MeasurementError::InvalidPayload {
node: node(1),
error: MeasurementPayloadError::InvalidPayloadVersion,
})
);
assert_eq!(
coordinator.set_spec(
node(1),
element(),
Some(spec(
MeasurementKind::NativeControl,
PendingMeasurePolicy::Placeholder(MeasuredSize::new(-1.0, 0.0)),
)),
),
Err(MeasurementError::InvalidPlaceholder { node: node(1) })
);
coordinator.begin_pass();
coordinator.measure(node(1), constraints(10.0));
assert_eq!(
coordinator.finish_pass(),
Err(MeasurementError::MissingSpec { node: node(1) })
);
coordinator
.set_spec(
node(1),
element(),
Some(spec(
MeasurementKind::EmbeddedSurface,
PendingMeasurePolicy::RetainPrevious,
)),
)
.unwrap();
coordinator.begin_pass();
assert_eq!(
coordinator.measure(node(1), constraints(10.0)),
LayoutSize::default()
);
let request = coordinator.finish_pass().unwrap().requests.remove(0);
let stale_key = MeasurementKey::new(999).expect("stale");
let apply = coordinator
.apply_batch(&[
MeasurementResponse::Ready {
key: stale_key,
environment_epoch: 1,
metrics: metrics(1.0, 1.0),
},
MeasurementResponse::Ready {
key: request.key,
environment_epoch: 2,
metrics: metrics(1.0, 1.0),
},
])
.unwrap();
assert_eq!(apply.stale(), 2);
assert_eq!(
coordinator.apply_batch(&[MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: MeasurementMetrics::from_size(MeasuredSize::new(-1.0, 1.0)),
}]),
Err(MeasurementError::InvalidMetrics { key: request.key })
);
assert!(coordinator.outstanding.contains_key(&request.key));
coordinator
.apply_batch(&[MeasurementResponse::Unsupported {
key: request.key,
environment_epoch: 1,
reason: UnsupportedMeasurementReason::Element,
}])
.unwrap();
coordinator.begin_pass();
coordinator.measure(node(1), constraints(10.0));
assert_eq!(
coordinator.finish_pass(),
Err(MeasurementError::Unsupported {
node: node(1),
reason: UnsupportedMeasurementReason::Element,
})
);
assert!(coordinator.set_spec(node(1), element(), None).unwrap());
assert!(!coordinator.set_spec(node(1), element(), None).unwrap());
coordinator.remove_node(node(1));
}
#[test]
fn duplicate_pending_ids_are_transactionally_rejected() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
for value in 1..=2 {
let mut value_spec = spec(
MeasurementKind::Custom { version: 1 },
PendingMeasurePolicy::Block,
);
value_spec.content_hash = value;
coordinator
.set_spec(node(value), element(), Some(value_spec))
.unwrap();
}
coordinator.begin_pass();
coordinator.measure(node(1), constraints(10.0));
coordinator.measure(node(2), constraints(10.0));
let requests = coordinator.finish_pass().unwrap().requests;
let request_id = MeasurementRequestId::new(7).expect("request");
let responses = requests
.iter()
.map(|request| MeasurementResponse::Pending {
key: request.key,
environment_epoch: 1,
request_id,
provisional: None,
})
.collect::<Vec<_>>();
assert_eq!(
coordinator.apply_batch(&responses),
Err(MeasurementError::DuplicateRequestId { request_id })
);
assert!(coordinator.cache.is_empty());
assert_eq!(coordinator.outstanding.len(), 2);
}
#[test]
fn batches_validate_before_commit_and_preserve_response_order() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
coordinator
.set_spec(
node(1),
element(),
Some(spec(
MeasurementKind::Custom { version: 1 },
PendingMeasurePolicy::Block,
)),
)
.unwrap();
coordinator.begin_pass();
coordinator.measure(node(1), constraints(10.0));
coordinator.measure(node(1), constraints(20.0));
let requests = coordinator.finish_pass().unwrap().requests;
let ready = |key, width| MeasurementResponse::Ready {
key,
environment_epoch: 1,
metrics: metrics(width, 1.0),
};
let first = ready(requests[0].key, 10.0);
let invalid = ready(requests[1].key, -1.0);
assert!(coordinator.apply_batch(&[first.clone(), invalid]).is_err());
assert_eq!(coordinator.outstanding.len(), 2);
assert!(coordinator.cache.is_empty());
assert!(coordinator.last_ready(node(1)).is_none());
let stale_epoch = MeasurementResponse::Ready {
key: requests[0].key,
environment_epoch: 0,
metrics: metrics(-1.0, 1.0),
};
let applied = coordinator
.apply_batch(&[
stale_epoch,
first,
ready(requests[0].key, -1.0),
ready(requests[1].key, 20.0),
])
.unwrap();
assert_eq!(applied.applied(), 2);
assert_eq!(applied.stale(), 2);
assert_eq!(applied.invalidated_nodes(), &[node(1)]);
assert_eq!(coordinator.last_ready(node(1)), Some(&metrics(20.0, 1.0)));
}
#[test]
fn retained_previous_metrics_and_key_exhaustion_are_covered() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
coordinator
.set_spec(
node(1),
element(),
Some(spec(
MeasurementKind::Text,
PendingMeasurePolicy::RetainPrevious,
)),
)
.unwrap();
coordinator.begin_pass();
coordinator.measure(node(1), constraints(10.0));
let request = coordinator.finish_pass().unwrap().requests.remove(0);
coordinator
.apply_batch(&[MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: metrics(5.0, 4.0),
}])
.unwrap();
let mut changed = spec(MeasurementKind::Text, PendingMeasurePolicy::RetainPrevious);
changed.content_hash = 99;
coordinator
.set_spec(node(1), element(), Some(changed))
.unwrap();
coordinator.begin_pass();
assert_eq!(
coordinator.measure(node(1), constraints(10.0)),
LayoutSize::new(5.0, 4.0)
);
assert!(coordinator.finish_pass().unwrap().provisional);
let mut exhausted = MeasurementCoordinator::default();
exhausted.set_environment(1);
exhausted.next_key = 0;
exhausted
.set_spec(
node(1),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
exhausted.begin_pass();
exhausted.measure(node(1), constraints(10.0));
assert_eq!(exhausted.finish_pass(), Err(MeasurementError::KeyExhausted));
}
#[test]
fn defensive_stale_entries_and_outstanding_cleanup_are_covered() {
assert_eq!(
AvailableSpaceKey::from(AvailableSpace::MinContent),
AvailableSpaceKey::MinContent
);
fn pending_coordinator() -> (MeasurementCoordinator, MeasurementReady, CacheKey) {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
coordinator
.set_spec(
node(1),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
coordinator.begin_pass();
coordinator.measure(node(1), constraints(10.0));
let key = coordinator.finish_pass().unwrap().requests[0].key;
let request_id = MeasurementRequestId::new(21).expect("request");
coordinator
.apply_batch(&[MeasurementResponse::Pending {
key,
environment_epoch: 1,
request_id,
provisional: None,
}])
.unwrap();
let cache_key = coordinator
.pending
.get(&request_id)
.expect("pending")
.cache_key
.clone();
(
coordinator,
MeasurementReady {
key,
request_id,
environment_epoch: 1,
metrics: metrics(2.0, 2.0),
},
cache_key,
)
}
let (mut missing_cache, ready, cache_key) = pending_coordinator();
missing_cache.cache.remove(&cache_key);
assert_eq!(
missing_cache.apply_ready(&ready).unwrap(),
DeferredMeasurementApply::IgnoredStale
);
let (mut wrong_state, ready, cache_key) = pending_coordinator();
wrong_state.cache.get_mut(&cache_key).expect("cache").state =
CachedState::Ready(metrics(1.0, 1.0));
assert_eq!(
wrong_state.apply_ready(&ready).unwrap(),
DeferredMeasurementApply::IgnoredStale
);
let (mut no_consumers, _, _) = pending_coordinator();
no_consumers.set_spec(node(1), element(), None).unwrap();
assert_eq!(no_consumers.pending_count(), 0);
assert!(no_consumers.cache.is_empty());
assert!(no_consumers.pending.is_empty());
assert!(no_consumers.consumer_keys.is_empty());
let mut outstanding = MeasurementCoordinator::default();
outstanding.set_environment(1);
for value in 1..=2 {
outstanding
.set_spec(
node(value),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
}
outstanding.begin_pass();
outstanding.measure(node(1), constraints(10.0));
outstanding.measure(node(2), constraints(10.0));
assert_eq!(outstanding.outstanding.len(), 1);
outstanding.set_spec(node(1), element(), None).unwrap();
assert_eq!(outstanding.outstanding.len(), 1);
outstanding.set_spec(node(2), element(), None).unwrap();
assert!(outstanding.outstanding.is_empty());
assert!(outstanding.outstanding_by_cache.is_empty());
assert!(outstanding.consumer_keys.is_empty());
let mut invalid_pending = MeasurementCoordinator::default();
invalid_pending.set_environment(1);
invalid_pending
.set_spec(
node(1),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
invalid_pending.begin_pass();
invalid_pending.measure(node(1), constraints(10.0));
let key = invalid_pending.finish_pass().unwrap().requests[0].key;
assert_eq!(
invalid_pending.apply_batch(&[MeasurementResponse::Pending {
key,
environment_epoch: 1,
request_id: MeasurementRequestId::new(22).expect("request"),
provisional: Some(MeasurementMetrics::from_size(MeasuredSize::new(
f32::NAN,
1.0,
))),
}]),
Err(MeasurementError::InvalidMetrics { key })
);
}
#[test]
fn unused_ready_cache_entries_are_reclaimed_without_breaking_shared_entries() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
for value in 1..=2 {
coordinator
.set_spec(
node(value),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
}
coordinator.begin_pass();
coordinator.measure(node(1), constraints(10.0));
coordinator.measure(node(2), constraints(10.0));
let request = coordinator.finish_pass().unwrap().requests.remove(0);
coordinator
.apply_batch(&[MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: metrics(5.0, 4.0),
}])
.unwrap();
assert_eq!(coordinator.cache.len(), 1);
coordinator
.set_spec(
node(3),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
coordinator.begin_pass();
assert_eq!(
coordinator.measure(node(3), constraints(10.0)),
LayoutSize::new(5.0, 4.0)
);
assert!(coordinator.finish_pass().unwrap().requests.is_empty());
coordinator.remove_node(node(1));
assert_eq!(coordinator.cache.len(), 1);
assert!(!coordinator.consumer_keys.contains_key(&node(1)));
coordinator.remove_node(node(2));
assert_eq!(coordinator.cache.len(), 1);
coordinator.remove_node(node(3));
assert!(coordinator.cache.is_empty());
assert!(coordinator.consumer_keys.is_empty());
}
#[test]
fn removing_last_pending_consumer_makes_deferred_completion_stale() {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
coordinator
.set_spec(
node(1),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
coordinator.begin_pass();
coordinator.measure(node(1), constraints(10.0));
let key = coordinator.finish_pass().unwrap().requests[0].key;
let request_id = MeasurementRequestId::new(30).expect("request");
coordinator
.apply_batch(&[MeasurementResponse::Pending {
key,
environment_epoch: 1,
request_id,
provisional: None,
}])
.unwrap();
coordinator.remove_node(node(1));
assert!(coordinator.pending.is_empty());
assert!(coordinator.cache.is_empty());
assert_eq!(
coordinator
.apply_ready(&MeasurementReady {
key,
request_id,
environment_epoch: 1,
metrics: metrics(5.0, 4.0),
})
.unwrap(),
DeferredMeasurementApply::IgnoredStale
);
}
#[test]
fn prepared_objects_follow_ready_pending_and_unsupported_cache_entries() {
for response_kind in 0..4 {
let mut coordinator = MeasurementCoordinator::default();
coordinator.set_environment(1);
coordinator
.set_spec(
node(1),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
coordinator.begin_pass();
coordinator.measure(node(1), constraints(100.0));
let request = coordinator.finish_pass().unwrap().requests.remove(0);
let response = match response_kind {
0 => MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: metrics(20.0, 10.0),
},
1 | 2 => MeasurementResponse::Pending {
key: request.key,
environment_epoch: 1,
request_id: MeasurementRequestId::new(1).unwrap(),
provisional: (response_kind == 1).then(|| metrics(20.0, 10.0)),
},
_ => MeasurementResponse::Unsupported {
key: request.key,
environment_epoch: 1,
reason: UnsupportedMeasurementReason::Element,
},
};
coordinator.apply_batch(&[response]).unwrap();
assert!(coordinator.selected(node(999), request.key).is_none());
let (revision, retained) = coordinator.retained_content();
let retained = retained.collect::<Vec<_>>();
assert_eq!(!retained.is_empty(), response_kind < 2);
assert!(
retained
.iter()
.all(|id| *id == PreparedContentId::new(3).unwrap())
);
assert_eq!(
coordinator.selected(node(1), request.key).is_some(),
response_kind == 0
);
coordinator.remove_node(node(1));
let (removed_revision, retained) = coordinator.retained_content();
assert!(removed_revision > revision);
assert_eq!(retained.count(), 0);
}
}
#[test]
fn paragraph_measurement_rejects_missing_and_mismatched_inline_subtrees() {
let mut coordinator = MeasurementCoordinator::default();
let attachment = crate::InlineAttachmentInput {
truncation: false,
label: None,
node: node(2),
range: whisker_protocol::TextByteRange { start: 0, end: 3 },
alignment: whisker_protocol::InlineAlignment::Baseline,
};
coordinator
.set_spec(
node(1),
element(),
Some(spec(MeasurementKind::Text, PendingMeasurePolicy::Block)),
)
.unwrap();
coordinator.set_inline_attachments(node(1), &[attachment]);
let other = MeasuredInlineChild {
node: node(3),
size: LayoutSize::new(10.0, 10.0),
baseline: 8.0,
};
for children in [vec![], vec![other]] {
coordinator.begin_pass();
assert_eq!(
coordinator
.measure_paragraph(node(1), constraints(100.0), &children)
.state,
MeasurementState::Blocked
);
assert_eq!(
coordinator.finish_pass(),
Err(MeasurementError::MissingSpec { node: node(1) })
);
}
}
}