use super::*;
use crate::{Bits, Encoding, Error};
fn bits(text: &str) -> Value {
Value::Bits(Bits::from_ascii(text.as_bytes()).unwrap())
}
fn waveform() -> Waveform {
Waveform::memory(
vec![Encoding::Bits { width: 8 }, Encoding::Event],
vec![
(0, 10, bits("00000000")),
(0, 20, bits("00000001")),
(1, 20, Value::Event { occurrences: 1 }),
(1, 20, Value::Event { occurrences: 1 }),
(0, 30, bits("10100001")),
(0, 30, bits("11110001")),
(0, 40, bits("11110001")),
],
None,
)
}
fn text(value: ValueRef<'_>) -> String {
match value {
ValueRef::Bits(bits) => bits.to_string(),
ValueRef::Event { .. } => "event".into(),
_ => panic!("unexpected value"),
}
}
#[test]
fn duplicate_projections_match_individual_normalized_scans() {
let mut wave = waveform();
let signals = wave.hierarchy().signals().collect::<Vec<_>>();
let wide = signals[0];
let high = wide.slice(7, 4).unwrap();
let low = wide.slice(0, 0).unwrap();
let selected = [high, wide, high, signals[1], low, wide, signals[1], low];
let range = TimeRange::from(Time::from_ticks(15));
let render = |record: ScanRef<'_>| match record {
ScanRef::Initial {
value, changed_at, ..
} => (None, changed_at, text(value)),
ScanRef::Change { time, value, .. } => (
Some(time),
None,
match value {
ValueRef::Event { occurrences } => occurrences.to_string(),
_ => text(value),
},
),
};
let mut expected = Vec::new();
for signal in selected {
let mut records = Vec::new();
let _ = wave
.select(&[signal])
.unwrap()
.scan(range, |record| {
records.push(render(record));
ControlFlow::<()>::Continue(())
})
.unwrap();
expected.push(records);
}
let mut actual = vec![Vec::new(); selected.len()];
let _ = wave
.select(&selected)
.unwrap()
.scan_each(range, |index, record| {
actual[index].push(render(record));
ControlFlow::<()>::Continue(())
})
.unwrap();
assert_eq!(actual, expected);
}
#[test]
fn samples_hold_final_tick_state_and_count_every_event() {
let mut wave = waveform();
let signals = wave.hierarchy().signals().collect::<Vec<_>>();
assert!(matches!(
wave.sample(signals[0], Time::ZERO).unwrap(),
Sample::Missing { .. }
));
assert!(matches!(
wave.sample(signals[1], Time::ZERO).unwrap(),
Sample::Event { occurrences: 0, .. }
));
let samples = wave
.samples(&[signals[1], signals[0], signals[1]], Time::from_ticks(20))
.unwrap();
assert!(matches!(samples[0], Sample::Event { occurrences: 2, .. }));
assert!(matches!(samples[2], Sample::Event { occurrences: 2, .. }));
assert_eq!(
samples.iter().map(Sample::signal).collect::<Vec<_>>(),
[signals[1], signals[0], signals[1]]
);
for tick in [30, 40, u64::MAX] {
let Sample::Value {
value, changed_at, ..
} = wave.sample(signals[0], Time::from_ticks(tick)).unwrap()
else {
panic!("missing state")
};
assert_eq!(text(value.as_ref()), "11110001");
assert_eq!(changed_at, Some(Time::from_ticks(30)));
}
}
#[test]
fn real_histories_retain_exact_representations() {
let first_nan = 0x7ff8_0000_0000_0001;
let second_nan = 0x7ff8_0000_0000_0002;
let observations = [
(1, first_nan, None),
(2, first_nan, None),
(3, second_nan, Some(3)),
(4, second_nan, Some(3)),
(5, 0.0f64.to_bits(), Some(5)),
(6, (-0.0f64).to_bits(), Some(6)),
];
let mut wave = Waveform::memory(
vec![Encoding::Real],
observations
.iter()
.map(|&(tick, bits, _)| (0, tick, Value::Real(f64::from_bits(bits))))
.collect(),
None,
);
let signal = wave.hierarchy().signals().next().unwrap();
for (tick, expected, changed) in observations {
let Sample::Value {
value: Value::Real(real),
changed_at,
..
} = wave.sample(signal, Time::from_ticks(tick)).unwrap()
else {
panic!("expected real sample")
};
assert_eq!(real.to_bits(), expected);
assert_eq!(changed_at, changed.map(Time::from_ticks));
}
let mut selection = wave.select(&[signal]).unwrap();
let traces = selection.traces(TimeRange::all()).unwrap();
let changes = traces[0]
.changes()
.iter()
.map(|change| {
let ValueRef::Real(real) = change.value() else {
panic!("expected real change")
};
(change.time().ticks(), real.to_bits())
})
.collect::<Vec<_>>();
assert_eq!(
changes,
[
(1, first_nan),
(3, second_nan),
(5, 0.0f64.to_bits()),
(6, (-0.0f64).to_bits())
]
);
let traces = selection
.traces(TimeRange::point(Time::from_ticks(4)))
.unwrap();
let initial = traces[0].initial().unwrap();
assert!(matches!(initial.value(), ValueRef::Real(real) if real.to_bits() == second_nan));
assert_eq!(initial.changed_at(), Some(Time::from_ticks(3)));
assert!(traces[0].changes().is_empty());
}
#[test]
fn slices_have_independent_changes_and_entering_states() {
let mut wave = waveform();
let base = wave.hierarchy().signals().next().unwrap();
let slice = base.slice(7, 4).unwrap();
let trace = wave
.trace(
slice,
TimeRange::closed(Time::from_ticks(20), Time::from_ticks(30)),
)
.unwrap();
assert_eq!(trace.signal(), slice);
assert_eq!(text(trace.initial().unwrap().value()), "0000");
assert_eq!(trace.initial().unwrap().changed_at(), None);
assert_eq!(
trace
.changes()
.iter()
.map(|c| (c.time().ticks(), text(c.value())))
.collect::<Vec<_>>(),
[(30, "1111".into())]
);
let Sample::Value {
value, changed_at, ..
} = wave.sample(slice, Time::from_ticks(25)).unwrap()
else {
panic!("missing state")
};
assert_eq!(text(value.as_ref()), "0000");
assert_eq!(changed_at, None);
let trace = wave
.trace(slice, TimeRange::point(Time::from_ticks(31)))
.unwrap();
assert_eq!(
trace.initial().unwrap().changed_at(),
Some(Time::from_ticks(30))
);
assert!(trace.changes().is_empty());
}
#[test]
fn scan_emits_initials_first_and_keeps_duplicate_entries() {
let mut wave = waveform();
let sigs = wave.hierarchy().signals().collect::<Vec<_>>();
let selected = [sigs[0], sigs[1], sigs[0]];
let mut selection = wave.select(&selected).unwrap();
assert_eq!(selection.signals(), selected);
let mut records = Vec::new();
let result = selection
.scan(
TimeRange::closed(Time::from_ticks(20), Time::from_ticks(30)),
|item| {
records.push(match item {
ScanRef::Initial { signal, value, .. } => (signal, None, text(value)),
ScanRef::Change {
signal,
time,
value,
} => (signal, Some(time.ticks()), text(value)),
});
ControlFlow::<()>::Continue(())
},
)
.unwrap();
assert_eq!(result, ControlFlow::Continue(()));
assert_eq!(
records
.iter()
.take(2)
.map(|r| (r.0, r.1))
.collect::<Vec<_>>(),
[(sigs[0], None), (sigs[0], None)]
);
assert!(records.iter().skip(2).all(|r| r.1.is_some()));
assert_eq!(records.iter().filter(|r| r.2 == "event").count(), 1);
assert_eq!(
records
.iter()
.filter(|r| r.1 == Some(30))
.map(|r| r.2.as_str())
.collect::<Vec<_>>(),
["11110001", "11110001"]
);
let traces = selection.traces(TimeRange::all()).unwrap();
assert_eq!(
traces.iter().map(Trace::signal).collect::<Vec<_>>(),
selected
);
assert_eq!(traces[0].changes().len(), 3);
assert_eq!(traces[2].changes().len(), 3);
assert_eq!(traces[1].changes().len(), 1);
let mut times = Vec::new();
let _ = selection
.scan_candidate_times(
TimeRange::closed(Time::from_ticks(20), Time::from_ticks(30)),
|t| {
times.push(t.ticks());
ControlFlow::<()>::Continue(())
},
)
.unwrap();
assert_eq!(times, [20, 30]);
}
#[test]
fn multiple_initials_follow_selection_order_not_history_order() {
let mut wave = Waveform::memory(
vec![
Encoding::Bits { width: 1 },
Encoding::Bits { width: 1 },
Encoding::Event,
Encoding::Bits { width: 1 },
],
vec![
(0, 1, bits("0")),
(1, 2, bits("1")),
(0, 3, bits("1")),
(2, 5, Value::Event { occurrences: 1 }),
(1, 5, bits("0")),
],
None,
);
let signals = wave.hierarchy().signals().collect::<Vec<_>>();
let selected = [signals[1], signals[2], signals[0], signals[1], signals[3]];
let mut selection = wave.select(&selected).unwrap();
assert_eq!(selection.hierarchy().signals().collect::<Vec<_>>(), signals);
let mut initials = Vec::new();
let mut changes = Vec::new();
let result = selection
.scan(TimeRange::point(Time::from_ticks(5)), |record| {
match record {
ScanRef::Initial {
signal,
value,
changed_at,
} => {
assert!(changes.is_empty(), "initial emitted after a change");
assert!(changed_at.is_none_or(|t| t < Time::from_ticks(5)));
initials.push((signal, text(value), changed_at));
}
ScanRef::Change {
signal,
time,
value,
} => {
changes.push((signal, time.ticks(), text(value)));
}
}
ControlFlow::<()>::Continue(())
})
.unwrap();
assert_eq!(result, ControlFlow::Continue(()));
assert_eq!(
initials
.iter()
.map(|(s, v, _)| (*s, v.as_str()))
.collect::<Vec<_>>(),
[(signals[1], "1"), (signals[0], "1"), (signals[1], "1")]
);
assert_eq!(initials[1].2, Some(Time::from_ticks(3)));
assert_eq!(changes.len(), 3);
assert_eq!(
changes
.iter()
.filter(|r| **r == (signals[1], 5, "0".into()))
.count(),
2
);
assert_eq!(
changes
.iter()
.filter(|r| **r == (signals[2], 5, "event".into()))
.count(),
1
);
}
#[test]
fn composed_projections_cohere_at_inclusive_boundaries() {
let mut wave = Waveform::memory(
vec![Encoding::Bits { width: 9 }],
vec![
(0, 2, bits("000000000")),
(0, 5, bits("000101000")),
(0, 5, bits("000010000")),
(0, 6, bits("100010001")), (0, 7, bits("100010001")),
(0, u64::MAX, bits("100111001")),
],
None,
);
let base = wave.hierarchy().signals().next().unwrap();
let composed = base.slice(7, 2).unwrap().slice(3, 1).unwrap();
let direct = base.slice(5, 3).unwrap();
assert_eq!(composed, direct);
let mut selection = wave.select(&[composed, direct]).unwrap();
for (range, initial, expected) in [
(
TimeRange::closed(Time::ZERO, Time::from_ticks(1)),
None,
vec![],
),
(
TimeRange::point(Time::from_ticks(2)),
None,
vec![(2, "000")],
),
(
TimeRange::point(Time::from_ticks(5)),
Some("000"),
vec![(5, "010")],
),
(TimeRange::point(Time::from_ticks(6)), Some("010"), vec![]),
(
TimeRange::from(Time::from_ticks(6)),
Some("010"),
vec![(u64::MAX, "111")],
),
(
TimeRange::point(Time::from_ticks(u64::MAX)),
Some("010"),
vec![(u64::MAX, "111")],
),
] {
for trace in selection.traces(range).unwrap() {
assert_eq!(trace.signal(), direct);
assert_eq!(trace.range(), range);
assert_eq!(
trace.initial().map(|v| text(v.value())),
initial.map(str::to_owned)
);
if let Some(state) = trace.initial() {
assert!(state.changed_at().is_none_or(|t| t < range.start()));
if initial == Some("010") {
assert_eq!(state.changed_at(), Some(Time::from_ticks(5)));
}
}
assert_eq!(
trace
.changes()
.iter()
.map(|c| (c.time().ticks(), text(c.value())))
.collect::<Vec<_>>(),
expected
.iter()
.map(|(t, v)| (*t, (*v).to_owned()))
.collect::<Vec<_>>()
);
}
let mut candidates = Vec::new();
assert_eq!(
selection
.scan_candidate_times(range, |time| {
candidates.push(time);
ControlFlow::<()>::Continue(())
})
.unwrap(),
ControlFlow::Continue(())
);
assert!(candidates.windows(2).all(|pair| pair[0] < pair[1]));
assert!(
candidates
.iter()
.all(|&t| t >= range.start() && range.end().is_none_or(|end| t <= end))
);
assert!(
expected
.iter()
.all(|(t, _)| candidates.contains(&Time::from_ticks(*t)))
);
}
for (tick, expected, changed) in [
(5, "010", 5),
(6, "010", 5),
(7, "010", 5),
(u64::MAX, "111", u64::MAX),
] {
for sample in selection.samples(Time::from_ticks(tick)).unwrap() {
let SampleRef::Value {
signal,
value,
changed_at,
} = sample.as_ref()
else {
panic!("expected projected persistent state")
};
assert_eq!(signal, direct);
assert_eq!(text(value), expected);
assert_eq!(changed_at, Some(Time::from_ticks(changed)));
}
}
}
#[test]
fn empty_histories_and_eof_bounds_are_successful_observations() {
let mut empty = Waveform::memory(
vec![Encoding::Real, Encoding::String, Encoding::Event],
vec![],
None,
);
assert_eq!(empty.metadata().time_span(), None);
let signals = empty.hierarchy().signals().collect::<Vec<_>>();
for tick in [Time::ZERO, Time::from_ticks(u64::MAX)] {
let samples = empty.samples(&signals, tick).unwrap();
for sample in &samples[..2] {
assert!(matches!(sample.as_ref(), SampleRef::Missing { .. }));
}
assert!(matches!(
samples[2].as_ref(),
SampleRef::Event { occurrences: 0, .. }
));
for range in [TimeRange::from(tick), TimeRange::point(tick)] {
for trace in empty.traces(&signals, range).unwrap() {
assert_eq!(trace.range(), range);
assert!(trace.initial().is_none());
assert!(trace.changes().is_empty());
if trace.signal().encoding() == Encoding::Event {
assert!(matches!(
trace.sample(tick).unwrap(),
SampleRef::Event { occurrences: 0, .. }
));
} else {
assert!(matches!(
trace.sample(tick).unwrap(),
SampleRef::Missing { .. }
));
}
}
let result = empty
.scan_candidate_times(&signals, range, |_| panic!("empty history candidate"))
.unwrap();
assert_eq!(result, ControlFlow::<()>::Continue(()));
}
}
let mut wave = waveform();
let signals = wave.hierarchy().signals().collect::<Vec<_>>();
assert_eq!(
wave.metadata().time_span().unwrap().last(),
Time::from_ticks(40)
);
for range in [
TimeRange::from(Time::from_ticks(40)),
TimeRange::closed(Time::from_ticks(41), Time::from_ticks(u64::MAX)),
] {
let traces = wave.traces(&signals, range).unwrap();
assert_eq!(traces[0].range(), range);
let initial = traces[0].initial().unwrap();
assert_eq!(text(initial.value()), "11110001");
assert_eq!(initial.changed_at(), Some(Time::from_ticks(30)));
assert!(traces.iter().all(|t| t.changes().is_empty()));
assert!(traces[1].initial().is_none());
}
for trace in wave
.traces(&signals, TimeRange::from(Time::from_ticks(41)))
.unwrap()
{
assert!(
trace.initial().is_some() || trace.signal().encoding() == Encoding::Event,
"unbounded range retains post-EOF entering state"
);
assert!(trace.changes().is_empty());
}
assert!(matches!(
wave.sample(signals[1], Time::from_ticks(u64::MAX)).unwrap(),
Sample::Event { occurrences: 0, .. }
));
}
#[test]
fn borrowed_mixed_values_remain_owned_after_queries_and_source_drop() {
let mut wave = Waveform::memory(
vec![
Encoding::Real,
Encoding::String,
Encoding::Bits { width: 9 },
],
vec![
(0, 2, Value::Real(1.25)),
(1, 2, Value::String("".into())),
(2, 2, bits("01XZHUWL-")),
(0, 3, Value::Real(-2.5)),
(1, 3, Value::String("new\0λ".into())),
(2, 3, bits("---------")),
],
None,
);
let signals = wave.hierarchy().signals().collect::<Vec<_>>();
let mut retained = Vec::new();
{
let mut selection = wave.select(&signals).unwrap();
assert_eq!(
selection
.visit_samples(Time::from_ticks(2), |sample| {
let SampleRef::Value {
signal,
value,
changed_at,
} = sample
else {
panic!("expected persistent value")
};
assert!(changed_at.is_none_or(|t| t <= Time::from_ticks(2)));
retained.push((signal, value.to_owned()));
ControlFlow::<()>::Continue(())
})
.unwrap(),
ControlFlow::Continue(())
);
}
let mut scanned = Vec::new();
let _ = wave
.scan(&signals, TimeRange::point(Time::from_ticks(3)), |record| {
match record {
ScanRef::Initial { signal, value, .. } => {
scanned.push((signal, None, value.to_owned()))
}
ScanRef::Change {
signal,
time,
value,
} => scanned.push((signal, Some(time), value.to_owned())),
}
ControlFlow::<()>::Continue(())
})
.unwrap();
let traces = wave
.traces(&signals, TimeRange::point(Time::from_ticks(3)))
.unwrap();
let samples = wave.samples(&signals, Time::from_ticks(3)).unwrap();
drop(wave);
let check = |index: usize, value: ValueRef<'_>, later: bool| match (index, value) {
(0, ValueRef::Real(real)) => assert_eq!(real, if later { -2.5 } else { 1.25 }),
(1, ValueRef::String(string)) => assert_eq!(string, if later { "new\0λ" } else { "" }),
(2, ValueRef::Bits(bits)) => {
assert_eq!(bits.width(), 9);
assert_eq!(
bits.to_string(),
if later { "---------" } else { "01xzhuwl-" }
);
}
_ => panic!("wrong value class"),
};
assert_eq!(retained.len(), 3);
assert_eq!(scanned.len(), 6);
for (index, (signal, value)) in retained.iter().enumerate() {
assert_eq!(*signal, signals[index]);
check(index, value.as_ref(), false);
let trace = &traces[index];
check(index, trace.initial().unwrap().value(), false);
assert_eq!(trace.changes().len(), 1);
assert_eq!(trace.changes()[0].time(), Time::from_ticks(3));
check(index, trace.changes()[0].value(), true);
let SampleRef::Value {
value, changed_at, ..
} = samples[index].as_ref()
else {
panic!("expected owned sample")
};
assert_eq!(changed_at, Some(Time::from_ticks(3)));
check(index, value, true);
}
for (signal, time, value) in scanned {
let index = signals.iter().position(|s| *s == signal).unwrap();
assert!(time.is_none_or(|t| t == Time::from_ticks(3)));
check(index, value.as_ref(), time.is_some());
}
}
#[test]
fn empty_ranges_and_selections_do_not_visit_or_read() {
let mut wave = Waveform::memory(
vec![Encoding::Bits { width: 8 }],
vec![(0, 0, bits("00000000"))],
Some(0),
);
let sig = wave.hierarchy().signals().next().unwrap();
let empty = TimeRange::closed(Time::from_ticks(2), Time::from_ticks(1));
let result = wave
.scan(&[sig], empty, |_| panic!("empty range visited"))
.unwrap();
assert_eq!(result, ControlFlow::<()>::Continue(()));
let trace = wave.trace(sig, empty).unwrap();
assert!(trace.initial().is_none() && trace.changes().is_empty());
assert!(wave.samples(&[], Time::ZERO).unwrap().is_empty());
assert!(wave.traces(&[], TimeRange::all()).unwrap().is_empty());
for (signals, range) in [(&[sig][..], empty), (&[][..], TimeRange::all())] {
assert_eq!(
wave.scan_candidate_times(signals, range, |_| panic!("empty candidates visited"))
.unwrap(),
ControlFlow::<()>::Continue(())
);
}
}
#[test]
fn breaks_stop_the_reader_and_late_errors_preserve_prior_callbacks() {
let mut wave = Waveform::memory(
vec![Encoding::Bits { width: 1 }],
vec![(0, 0, bits("0")), (0, 1, bits("1")), (0, 1, bits("0"))],
Some(2),
);
let sig = wave.hierarchy().signals().next().unwrap();
let mut calls = 0;
assert_eq!(
wave.scan(&[sig], TimeRange::all(), |_| {
calls += 1;
ControlFlow::Break("stop")
})
.unwrap(),
ControlFlow::Break("stop")
);
assert_eq!(calls, 1);
calls = 0;
let result = wave.scan(&[sig], TimeRange::all(), |_| {
calls += 1;
ControlFlow::<()>::Continue(())
});
assert!(matches!(result, Err(Error::Backend { .. })));
assert_eq!(calls, 1);
assert!(wave.trace(sig, TimeRange::all()).is_err());
assert!(matches!(
wave.samples(&[sig, sig], Time::from_ticks(1)),
Err(Error::Backend { .. })
));
let mut sample_calls = 0;
let result = wave
.select(&[sig])
.unwrap()
.visit_samples(Time::from_ticks(1), |_| {
sample_calls += 1;
ControlFlow::<()>::Continue(())
});
assert!(matches!(result, Err(Error::Backend { .. })));
assert_eq!(sample_calls, 0);
let mut times = Vec::new();
assert_eq!(
wave.scan_candidate_times(&[sig], TimeRange::all(), |t| {
times.push(t);
ControlFlow::Break(7)
})
.unwrap(),
ControlFlow::Break(7)
);
assert_eq!(times, [Time::ZERO]);
}
#[test]
fn real_and_string_excursions_do_not_change_retained_state() {
let nan = Value::Real(f64::from_bits(0x7ff8_0000_0000_0001));
let string = Value::String("held\0é".into());
for (encoding, entering, excursion) in [
(
Encoding::Real,
nan,
Value::Real(f64::from_bits(0x7ff8_0000_0000_0002)),
),
(Encoding::String, string, Value::String("other".into())),
] {
let mut wave = Waveform::memory(
vec![encoding],
vec![
(0, 0, entering.clone()),
(0, 4, excursion),
(0, 4, entering.clone()),
],
None,
);
let signal = wave.hierarchy().signals().next().unwrap();
let Sample::Value {
value, changed_at, ..
} = wave.sample(signal, Time::from_ticks(4)).unwrap()
else {
panic!("expected state")
};
assert!(value.same_value(&entering));
assert_eq!(changed_at, None);
let trace = wave
.trace(signal, TimeRange::point(Time::from_ticks(4)))
.unwrap();
assert!(trace.changes().is_empty());
assert!(
trace
.initial()
.unwrap()
.value()
.same_value(entering.as_ref())
);
}
}
#[test]
fn query_reads_nondrivers_between_distant_candidates() {
let mut wave = Waveform::memory(
vec![
Encoding::Bits { width: 1 },
Encoding::Bits { width: 2 },
Encoding::Event,
Encoding::Real,
],
vec![
(0, 0, bits("0")),
(1, 0, bits("00")),
(0, 100, bits("1")),
(1, 150, bits("10")),
(2, 150, Value::Event { occurrences: 3 }),
(1, 199, bits("11")),
(2, 199, Value::Event { occurrences: 2 }),
(0, 200, bits("0")),
(1, 200, bits("10")),
],
None,
);
let base = wave.hierarchy().signals().collect::<Vec<_>>();
let selected = [
base[0],
base[1],
base[1].slice(1, 1).unwrap(),
base[1].slice(0, 0).unwrap(),
base[2],
base[2],
base[3],
];
let mut selection = wave.select(&selected).unwrap();
let mut candidates = Vec::new();
let _ = selection.query(TimeRange::closed(Time::from_ticks(100), Time::from_ticks(200)), &[0], |ctx| {
candidates.push(ctx.time().ticks());
if ctx.time().ticks() == 200 {
for tick in [199, 200, 199] {
let _ = ctx.visit_samples(Time::from_ticks(tick), &[1, 2, 3, 4, 5, 6], |index, sample| {
if index <= 3 {
let SampleRef::Value { value, changed_at, .. } = sample else { panic!("expected persistent value") };
let (expected, changed) = match index {
1 => (if tick == 199 { "11" } else { "10" }, tick),
2 => ("1", 150),
3 => (if tick == 199 { "1" } else { "0" }, tick),
_ => unreachable!(),
};
assert_eq!(text(value), expected);
assert_eq!(changed_at, Some(Time::from_ticks(changed)));
} else if index <= 5 {
assert!(matches!(sample, SampleRef::Event { occurrences, .. } if occurrences == if tick == 199 { 2 } else { 0 }));
} else { assert!(matches!(sample, SampleRef::Missing { .. })); }
Ok(ControlFlow::<()>::Continue(()))
})?;
}
}
Ok(ControlFlow::<()>::Continue(()))
}).unwrap();
assert_eq!(candidates, [100, 200]);
let mut events = Vec::new();
let _ = selection
.query(TimeRange::from(Time::from_ticks(101)), &[4, 5], |ctx| {
let t = ctx.time();
let _ = ctx.visit_samples(
Time::from_ticks(t.ticks().checked_sub(1).unwrap()),
&[4],
|_, sample| {
assert!(matches!(sample, SampleRef::Event { occurrences: 0, .. }));
Ok(ControlFlow::<()>::Continue(()))
},
)?;
ctx.visit_samples(t, &[4], |_, sample| {
let SampleRef::Event { occurrences, .. } = sample else {
panic!("expected event")
};
events.push((t.ticks(), occurrences));
Ok(ControlFlow::<()>::Continue(()))
})
})
.unwrap();
assert_eq!(events, [(150, 3), (199, 2)]);
}
#[test]
fn query_samples_match_normalized_points_for_all_value_classes() {
let nan = Value::Real(f64::from_bits(0x7ff8_0000_0000_0001));
let mut wave = Waveform::memory(
vec![
Encoding::Real,
Encoding::String,
Encoding::Bits { width: 1 },
Encoding::Event,
],
vec![
(0, 0, nan.clone()),
(1, 0, Value::String("A".into())),
(2, 0, bits("x")),
(3, 0, Value::Event { occurrences: 2 }),
(0, 3, Value::Real(f64::from_bits(0x7ff8_0000_0000_0002))),
(1, 3, Value::String("B".into())),
(2, 3, bits("1")),
(0, 3, nan),
(1, 3, Value::String("A".into())),
(2, 3, bits("x")),
(3, 3, Value::Event { occurrences: 1 }),
(0, 5, Value::Real(-0.0)),
(1, 5, Value::String("é\0😀".into())),
(2, 5, bits("1")),
(0, 6, Value::Real(0.0)),
],
None,
);
let signals = wave.hierarchy().signals().collect::<Vec<_>>();
let mut selection = wave.select(&signals).unwrap();
let expected = [0, 2, 3, 4, 5, 6]
.into_iter()
.map(|tick| {
(
Time::from_ticks(tick),
selection.samples(Time::from_ticks(tick)).unwrap(),
)
})
.collect::<Vec<_>>();
let mut candidates = Vec::new();
let _ = selection
.query(TimeRange::all(), &[0, 1, 2, 3], |ctx| {
candidates.push(ctx.time().ticks());
for time in std::iter::once(ctx.time())
.chain(ctx.time().ticks().checked_sub(1).map(Time::from_ticks))
{
let reference = &expected.iter().find(|(tick, _)| *tick == time).unwrap().1;
let _ = ctx.visit_samples(time, &[0, 1, 2, 3], |index, sample| {
match (sample, reference[index].as_ref()) {
(
SampleRef::Value {
signal,
value,
changed_at,
},
SampleRef::Value {
signal: expected_signal,
value: expected_value,
changed_at: expected_time,
},
) => {
assert_eq!(signal, expected_signal);
assert!(value.same_value(expected_value));
assert_eq!(changed_at, expected_time);
}
(
SampleRef::Event { occurrences, .. },
SampleRef::Event {
occurrences: expected,
..
},
) => assert_eq!(occurrences, expected),
_ => panic!("sample class mismatch"),
}
Ok(ControlFlow::<()>::Continue(()))
})?;
}
Ok(ControlFlow::<()>::Continue(()))
})
.unwrap();
assert_eq!(candidates, [0, 3, 5, 6]);
}
#[test]
fn query_never_publishes_incomplete_ticks_and_empty_drivers_do_not_read() {
for fail_after in [0, 1, 2] {
let mut wave = Waveform::memory(
vec![Encoding::Real],
vec![
(0, 0, Value::Real(0.0)),
(0, 1, Value::Real(1.0)),
(0, 1, Value::Real(2.0)),
],
Some(fail_after),
);
let signal = wave.hierarchy().signals().next().unwrap();
let mut selection = wave.select(&[signal]).unwrap();
let mut ticks = Vec::new();
let result = selection.query(TimeRange::all(), &[0], |ctx| {
ticks.push(ctx.time().ticks());
Ok(ControlFlow::<()>::Continue(()))
});
assert!(result.is_err());
assert_eq!(ticks, if fail_after == 2 { vec![0] } else { vec![] });
assert_eq!(
selection
.query(TimeRange::all(), &[], |_| -> Result<ControlFlow<()>> {
panic!("empty drivers")
})
.unwrap(),
ControlFlow::Continue(())
);
if fail_after == 2 {
assert_eq!(
selection
.query(TimeRange::all(), &[0], |_| Ok(ControlFlow::Break(7)))
.unwrap(),
ControlFlow::Break(7)
);
}
}
}
#[test]
fn indexed_and_plain_scans_share_empty_break_and_error_behavior() {
for indexed in [false, true] {
for empty in [false, true] {
for stop in [false, true] {
let mut wave = Waveform::memory(
vec![Encoding::Bits { width: 1 }],
vec![(0, 0, bits("0")), (0, 1, bits("1")), (0, 1, bits("0"))],
Some(2),
);
let signal = wave.hierarchy().signals().next().unwrap();
let signals = if empty { vec![] } else { vec![signal] };
let mut selection = wave.select(&signals).unwrap();
let mut observed = Vec::new();
let mut visit = |index, record: ScanRef<'_>| {
assert_eq!(index, 0);
let ScanRef::Change { time, value, .. } = record else {
panic!("unexpected initial")
};
observed.push((time.ticks(), text(value)));
if stop {
ControlFlow::Break(17)
} else {
ControlFlow::Continue(())
}
};
let result = if indexed {
selection.scan_each(TimeRange::all(), &mut visit)
} else {
selection.scan(TimeRange::all(), |record| visit(0, record))
};
if empty {
assert!(matches!(result, Ok(ControlFlow::Continue(()))));
assert!(observed.is_empty());
} else {
assert_eq!(observed, [(0, "0".to_owned())]);
if stop {
assert_eq!(result.unwrap(), ControlFlow::Break(17));
} else {
assert!(result.is_err());
}
}
}
}
}
}
#[test]
fn incomplete_first_tick_is_not_published_on_error() {
let mut wave = Waveform::memory(
vec![Encoding::Bits { width: 1 }],
vec![(0, 0, bits("0")), (0, 0, bits("1"))],
Some(1),
);
let signal = wave.hierarchy().signals().next().unwrap();
assert!(
wave.scan(&[signal], TimeRange::all(), |_| -> ControlFlow<()> {
panic!("unfinished tick must not be published")
})
.is_err()
);
}
#[test]
fn final_tick_excursions_preserve_projected_change_times() {
for swap_signals in [false, true] {
let mut records = vec![
(0, 2, bits("00")),
(1, 2, bits("x")), (0, 3, bits("01")),
(0, 5, bits("11")),
(1, 5, bits("0")),
(0, 5, bits("01")), (1, 5, bits("x")),
(0, 7, bits("11")),
(0, 7, bits("00")), ];
if swap_signals {
records.sort_by_key(|(signal, tick, _)| (*tick, 1 - signal));
}
let mut wave = Waveform::memory(
vec![Encoding::Bits { width: 2 }, Encoding::Bits { width: 1 }],
records,
None,
);
let signals = wave.hierarchy().signals().collect::<Vec<_>>();
let high = signals[0].slice(1, 1).unwrap();
let selected = [signals[0], high, high, signals[1]];
let mut selection = wave.select(&selected).unwrap();
assert!(
selection
.samples(Time::from_ticks(1))
.unwrap()
.iter()
.all(|sample| matches!(sample, Sample::Missing { .. }))
);
for (tick, values, times) in [
(5, ["01", "0", "0", "x"], [Some(3), None, None, None]),
(7, ["00", "0", "0", "x"], [Some(7), None, None, None]),
(u64::MAX, ["00", "0", "0", "x"], [Some(7), None, None, None]),
] {
for ((sample, expected), changed) in selection
.samples(Time::from_ticks(tick))
.unwrap()
.iter()
.zip(values)
.zip(times)
{
let SampleRef::Value {
value, changed_at, ..
} = sample.as_ref()
else {
panic!("expected state")
};
assert_eq!(text(value), expected);
assert_eq!(changed_at, changed.map(Time::from_ticks));
}
}
let traces = selection.traces(TimeRange::all()).unwrap();
for (trace, expected) in traces.iter().zip([
vec![(2, "00"), (3, "01"), (7, "00")],
vec![(2, "0")],
vec![(2, "0")],
vec![(2, "x")],
]) {
assert_eq!(
trace
.changes()
.iter()
.map(|c| (c.time().ticks(), text(c.value())))
.collect::<Vec<_>>(),
expected
.iter()
.map(|(t, v)| (*t, (*v).to_owned()))
.collect::<Vec<_>>()
);
}
for range in [
TimeRange::point(Time::from_ticks(5)),
TimeRange::point(Time::from_ticks(6)),
] {
let traces = selection.traces(range).unwrap();
assert!(traces.iter().all(|trace| trace.changes().is_empty()));
assert_eq!(
traces[0].initial().unwrap().changed_at(),
Some(Time::from_ticks(3))
);
}
}
}
#[test]
fn invalid_and_unsupported_signals_fail_before_queries() {
let mut wave = waveform();
let other = waveform().hierarchy().signals().next().unwrap();
assert!(matches!(
wave.sample(other, Time::ZERO),
Err(Error::InvalidSignal { .. })
));
let mut unsupported = Waveform::memory(vec![Encoding::Unsupported], vec![], None);
let sig = unsupported.hierarchy().signals().next().unwrap();
assert!(matches!(
unsupported.sample(sig, Time::ZERO),
Err(Error::UnsupportedSignal { .. })
));
}
#[test]
fn event_aggregates_preserve_counts_boundaries_and_duplicates() {
let mut wave = Waveform::memory(
vec![Encoding::Event],
vec![
(0, 2, Value::Event { occurrences: 1 }),
(0, 5, Value::Event { occurrences: 1 }),
(0, 5, Value::Event { occurrences: 1 }),
],
None,
);
let signal = wave.hierarchy().signals().next().unwrap();
let mut selection = wave.select(&[signal, signal]).unwrap();
for (tick, expected) in [(0, 0), (2, 1), (3, 0), (5, 2), (6, 0), (u64::MAX, 0)] {
for sample in selection.samples(Time::from_ticks(tick)).unwrap() {
assert!(matches!(sample, Sample::Event { occurrences, .. } if occurrences == expected));
}
for trace in selection
.traces(TimeRange::point(Time::from_ticks(tick)))
.unwrap()
{
assert!(trace.initial().is_none());
assert_eq!(trace.changes().len(), usize::from(expected > 0));
if expected > 0 {
assert!(
matches!(trace.changes()[0].value(), ValueRef::Event { occurrences } if occurrences == expected)
);
}
}
}
let range = TimeRange::closed(Time::from_ticks(2), Time::from_ticks(5));
let mut observed = Vec::new();
let _ = selection
.scan(range, |record| {
let ScanRef::Change {
time,
value: ValueRef::Event { occurrences },
..
} = record
else {
panic!("expected event aggregate")
};
observed.push((time.ticks(), occurrences));
ControlFlow::<()>::Continue(())
})
.unwrap();
assert_eq!(observed, [(2, 1), (2, 1), (5, 2), (5, 2)]);
let mut candidates = Vec::new();
let _ = selection
.scan_candidate_times(range, |time| {
candidates.push(time.ticks());
ControlFlow::<()>::Continue(())
})
.unwrap();
assert_eq!(candidates, [2, 5]);
let traces = selection.traces(range).unwrap();
drop(wave);
for trace in traces {
assert!(matches!(
trace.changes()[1].value(),
ValueRef::Event { occurrences: 2 }
));
}
}
#[test]
fn event_count_overflow_is_an_error_not_a_partial_tick() {
for overflow in [false, true] {
let mut records = vec![(
0,
0,
Value::Event {
occurrences: u64::MAX,
},
)];
if overflow {
records.push((0, 0, Value::Event { occurrences: 1 }));
}
let mut wave = Waveform::memory(vec![Encoding::Event], records, None);
let signal = wave.hierarchy().signals().next().unwrap();
let result = wave.sample(signal, Time::ZERO);
if overflow {
assert!(matches!(
result,
Err(Error::Backend {
operation: "count events",
..
})
));
assert!(
wave.scan(
&[signal, signal],
TimeRange::all(),
|_| -> ControlFlow<()> { panic!("overflowed tick must not be published") }
)
.is_err()
);
assert!(wave.trace(signal, TimeRange::all()).is_err());
} else {
assert!(matches!(
result,
Ok(Sample::Event {
occurrences: u64::MAX,
..
})
));
let traces = wave.traces(&[signal, signal], TimeRange::all()).unwrap();
for trace in traces {
assert_eq!(trace.changes().len(), 1);
assert!(matches!(
trace.changes()[0].value(),
ValueRef::Event {
occurrences: u64::MAX
}
));
}
}
}
}
#[test]
fn genuine_tick_zero_events_and_borrowed_sample_breaks_survive() {
let mut wave = Waveform::memory(
vec![Encoding::Event],
vec![
(0, 0, Value::Event { occurrences: 1 }),
(0, 0, Value::Event { occurrences: 1 }),
],
None,
);
let sig = wave.hierarchy().signals().next().unwrap();
assert!(matches!(
wave.sample(sig, Time::ZERO).unwrap(),
Sample::Event { occurrences: 2, .. }
));
assert_eq!(
wave.trace(sig, TimeRange::point(Time::ZERO))
.unwrap()
.changes()
.len(),
1
);
let mut calls = 0;
let result = wave
.select(&[sig, sig])
.unwrap()
.visit_samples(Time::ZERO, |sample| {
calls += 1;
assert_eq!(sample.signal(), sig);
ControlFlow::Break("first")
})
.unwrap();
assert_eq!(result, ControlFlow::Break("first"));
assert_eq!(calls, 1);
}