268 lines
8.9 KiB
Rust
268 lines
8.9 KiB
Rust
use crate::rangefilter2::RangeFilter2;
|
|
use futures_util::Stream;
|
|
use futures_util::StreamExt;
|
|
use items_0::streamitem::RangeCompletableItem;
|
|
use items_0::streamitem::Sitemty;
|
|
use items_0::streamitem::StreamItem;
|
|
use items_0::Events;
|
|
use netpod::range::evrange::NanoRange;
|
|
use netpod::TsNano;
|
|
use std::collections::VecDeque;
|
|
|
|
#[test]
|
|
fn test_00() {
|
|
use items_0::Empty;
|
|
use items_2::eventsdim0::EventsDim0;
|
|
let ms = 1_000_000;
|
|
let beg = TsNano::from_ms(1000 * 10);
|
|
let end = TsNano::from_ms(1000 * 20);
|
|
let mut item1 = EventsDim0::<f32>::empty();
|
|
item1.push_back(beg.ns() + 0 * ms, 0, 3.);
|
|
item1.push_back(beg.ns() + 1 * ms, 0, 3.1);
|
|
item1.push_back(beg.ns() + 2 * ms, 0, 3.2);
|
|
item1.push_back(beg.ns() + 3 * ms, 0, 3.3);
|
|
item1.push_back(beg.ns() + 4 * ms, 0, 3.4);
|
|
item1.push_back(end.ns() - 1, 0, 4.0);
|
|
item1.push_back(end.ns() + 0, 0, 4.1);
|
|
item1.push_back(end.ns() + 1, 0, 4.1);
|
|
let w1: Box<dyn Events> = Box::new(item1.clone());
|
|
let e1 = Ok(StreamItem::DataItem(RangeCompletableItem::Data(w1)));
|
|
let inp = futures_util::stream::iter([e1]);
|
|
let one_before_range = false;
|
|
let range = NanoRange::from((beg.ns(), end.ns()));
|
|
let stream = RangeFilter2::new(inp, range, one_before_range);
|
|
let fut = async move {
|
|
let tss_items = fetch_into_tss_items(stream).await;
|
|
let exp: &[&[u64]] = &[&[
|
|
beg.ns() + 0 * ms,
|
|
beg.ns() + 1 * ms,
|
|
beg.ns() + 2 * ms,
|
|
beg.ns() + 3 * ms,
|
|
beg.ns() + 4 * ms,
|
|
end.ns() - 1,
|
|
]];
|
|
assert_eq!(&tss_items, &exp);
|
|
Ok::<_, Error>(())
|
|
};
|
|
taskrun::run(fut).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn test_cut_before_00() {
|
|
use items_0::Empty;
|
|
use items_2::eventsdim0::EventsDim0;
|
|
let ms = 1_000_000;
|
|
let beg = TsNano::from_ms(1000 * 10);
|
|
let end = TsNano::from_ms(1000 * 20);
|
|
let mut items = Vec::new();
|
|
{
|
|
let mut item = EventsDim0::<f32>::empty();
|
|
item.push_back(beg.ns() - 1, 0, 2.9);
|
|
let w: Box<dyn Events> = Box::new(item.clone());
|
|
let e: Sitemty<_> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(w)));
|
|
items.push(e);
|
|
}
|
|
{
|
|
let mut item = EventsDim0::<f32>::empty();
|
|
item.push_back(beg.ns() + 0 * ms, 0, 3.);
|
|
item.push_back(beg.ns() + 1 * ms, 0, 3.1);
|
|
item.push_back(beg.ns() + 2 * ms, 0, 3.2);
|
|
item.push_back(beg.ns() + 3 * ms, 0, 3.3);
|
|
item.push_back(beg.ns() + 4 * ms, 0, 3.4);
|
|
item.push_back(end.ns() - 1, 0, 4.0);
|
|
item.push_back(end.ns() + 0, 0, 4.1);
|
|
item.push_back(end.ns() + 1, 0, 4.1);
|
|
let w: Box<dyn Events> = Box::new(item.clone());
|
|
let e: Sitemty<_> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(w)));
|
|
items.push(e);
|
|
}
|
|
let inp = futures_util::stream::iter(items);
|
|
let one_before_range = false;
|
|
let range = NanoRange::from((beg.ns(), end.ns()));
|
|
let stream = RangeFilter2::new(inp, range, one_before_range);
|
|
let fut = async move {
|
|
let tss_items = fetch_into_tss_items(stream).await;
|
|
let exp: &[&[u64]] = &[
|
|
// TODO in the future this empty may be discarded
|
|
&[],
|
|
&[
|
|
beg.ns() + 0 * ms,
|
|
beg.ns() + 1 * ms,
|
|
beg.ns() + 2 * ms,
|
|
beg.ns() + 3 * ms,
|
|
beg.ns() + 4 * ms,
|
|
end.ns() - 1,
|
|
],
|
|
];
|
|
assert_eq!(&tss_items, &exp);
|
|
Ok::<_, Error>(())
|
|
};
|
|
taskrun::run(fut).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn test_one_before_00() {
|
|
use items_0::Empty;
|
|
use items_2::eventsdim0::EventsDim0;
|
|
let ms = 1_000_000;
|
|
let beg = TsNano::from_ms(1000 * 10);
|
|
let end = TsNano::from_ms(1000 * 20);
|
|
let mut items = Vec::new();
|
|
{
|
|
let mut item = EventsDim0::<f32>::empty();
|
|
item.push_back(beg.ns() - 1, 0, 2.9);
|
|
let w: Box<dyn Events> = Box::new(item.clone());
|
|
let e: Sitemty<_> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(w)));
|
|
items.push(e);
|
|
}
|
|
{
|
|
let mut item = EventsDim0::<f32>::empty();
|
|
item.push_back(beg.ns() + 0 * ms, 0, 3.);
|
|
item.push_back(beg.ns() + 1 * ms, 0, 3.1);
|
|
item.push_back(beg.ns() + 2 * ms, 0, 3.2);
|
|
item.push_back(beg.ns() + 3 * ms, 0, 3.3);
|
|
item.push_back(beg.ns() + 4 * ms, 0, 3.4);
|
|
item.push_back(end.ns() - 1, 0, 4.0);
|
|
item.push_back(end.ns() + 0, 0, 4.1);
|
|
item.push_back(end.ns() + 1, 0, 4.1);
|
|
let w: Box<dyn Events> = Box::new(item.clone());
|
|
let e: Sitemty<_> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(w)));
|
|
items.push(e);
|
|
}
|
|
let inp = futures_util::stream::iter(items);
|
|
let one_before_range = true;
|
|
let range = NanoRange::from((beg.ns(), end.ns()));
|
|
let stream = RangeFilter2::new(inp, range, one_before_range);
|
|
let fut = async move {
|
|
let tss_items = fetch_into_tss_items(stream).await;
|
|
let exp: &[&[u64]] = &[
|
|
// TODO in the future this empty may be discarded
|
|
&[],
|
|
&[
|
|
//
|
|
beg.ns() - 1,
|
|
],
|
|
&[
|
|
beg.ns() + 0 * ms,
|
|
beg.ns() + 1 * ms,
|
|
beg.ns() + 2 * ms,
|
|
beg.ns() + 3 * ms,
|
|
beg.ns() + 4 * ms,
|
|
end.ns() - 1,
|
|
],
|
|
];
|
|
assert_eq!(&tss_items, &exp);
|
|
Ok::<_, Error>(())
|
|
};
|
|
taskrun::run(fut).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn test_one_before_01() {
|
|
use items_0::Empty;
|
|
use items_2::eventsdim0::EventsDim0;
|
|
let ms = 1_000_000;
|
|
let beg = TsNano::from_ms(1000 * 10);
|
|
let end = TsNano::from_ms(1000 * 20);
|
|
let mut items = Vec::new();
|
|
{
|
|
let mut item = EventsDim0::<f32>::empty();
|
|
item.push_back(beg.ns() - 1, 0, 2.9);
|
|
item.push_back(beg.ns() + 0 * ms, 0, 3.);
|
|
let w: Box<dyn Events> = Box::new(item.clone());
|
|
let e: Sitemty<_> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(w)));
|
|
items.push(e);
|
|
}
|
|
{
|
|
let mut item = EventsDim0::<f32>::empty();
|
|
item.push_back(beg.ns() + 1 * ms, 0, 3.1);
|
|
item.push_back(beg.ns() + 2 * ms, 0, 3.2);
|
|
item.push_back(beg.ns() + 3 * ms, 0, 3.3);
|
|
item.push_back(beg.ns() + 4 * ms, 0, 3.4);
|
|
item.push_back(end.ns() - 1, 0, 4.0);
|
|
item.push_back(end.ns() + 0, 0, 4.1);
|
|
item.push_back(end.ns() + 1, 0, 4.1);
|
|
let w: Box<dyn Events> = Box::new(item.clone());
|
|
let e: Sitemty<_> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(w)));
|
|
items.push(e);
|
|
}
|
|
let inp = futures_util::stream::iter(items);
|
|
let one_before_range = true;
|
|
let range = NanoRange::from((beg.ns(), end.ns()));
|
|
let stream = RangeFilter2::new(inp, range, one_before_range);
|
|
let fut = async move {
|
|
let tss_items = fetch_into_tss_items(stream).await;
|
|
let exp: &[&[u64]] = &[
|
|
// TODO in the future this empty may be discarded
|
|
// &[],
|
|
&[
|
|
//
|
|
beg.ns() - 1,
|
|
beg.ns() + 0 * ms,
|
|
],
|
|
&[
|
|
beg.ns() + 1 * ms,
|
|
beg.ns() + 2 * ms,
|
|
beg.ns() + 3 * ms,
|
|
beg.ns() + 4 * ms,
|
|
end.ns() - 1,
|
|
],
|
|
];
|
|
assert_eq!(&tss_items, &exp);
|
|
Ok::<_, Error>(())
|
|
};
|
|
taskrun::run(fut).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn test_one_before_only() {
|
|
use items_0::Empty;
|
|
use items_2::eventsdim0::EventsDim0;
|
|
let _ms = 1_000_000;
|
|
let beg = TsNano::from_ms(1000 * 10);
|
|
let end = TsNano::from_ms(1000 * 20);
|
|
let mut items = Vec::new();
|
|
{
|
|
let mut item = EventsDim0::<f32>::empty();
|
|
item.push_back(beg.ns() - 1, 0, 2.9);
|
|
let w: Box<dyn Events> = Box::new(item.clone());
|
|
let e: Sitemty<_> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(w)));
|
|
items.push(e);
|
|
}
|
|
let inp = futures_util::stream::iter(items);
|
|
let one_before_range = true;
|
|
let range = NanoRange::from((beg.ns(), end.ns()));
|
|
let stream = RangeFilter2::new(inp, range, one_before_range);
|
|
let fut = async move {
|
|
let tss_items = fetch_into_tss_items(stream).await;
|
|
let exp: &[&[u64]] = &[
|
|
// TODO in the future this empty may be discarded
|
|
&[],
|
|
&[
|
|
//
|
|
beg.ns() - 1,
|
|
],
|
|
];
|
|
assert_eq!(&tss_items, &exp);
|
|
Ok::<_, Error>(())
|
|
};
|
|
taskrun::run(fut).unwrap();
|
|
}
|
|
|
|
#[cfg(test)]
|
|
async fn fetch_into_tss_items<INP>(mut inp: INP) -> VecDeque<VecDeque<u64>>
|
|
where
|
|
INP: Stream<Item = Sitemty<Box<dyn Events>>> + Unpin,
|
|
{
|
|
let mut tss_items = VecDeque::new();
|
|
while let Some(e) = inp.next().await {
|
|
if let Ok(StreamItem::DataItem(RangeCompletableItem::Data(evs))) = e {
|
|
eprintln!("{:?}", evs);
|
|
tss_items.push_back(Events::tss(&evs).clone());
|
|
} else {
|
|
eprintln!("other item ----------: {:?}", e);
|
|
}
|
|
}
|
|
tss_items
|
|
}
|