WIP time bin chain test case

streams/src/generators.rs

@@ -22,6 +22,8 @@ pub struct GenerateI32 {
     ts: u64,
     dts: u64,
     tsend: u64,
+    #[allow(unused)]
+    c1: u64,
     timeout: Option<Pin<Box<dyn Future<Output = ()> + Send>>>,
 }
 
@@ -38,6 +40,7 @@ impl GenerateI32 {
             ts,
             dts,
             tsend,
+            c1: 0,
             timeout: None,
         }
     }
@@ -51,12 +54,14 @@ impl GenerateI32 {
                 break;
             }
             let pulse = ts;
-            item.push(ts, pulse, pulse as T);
+            let value = (ts / (MS * 100) % 1000) as T;
+            item.push(ts, pulse, value);
             ts += self.dts;
         }
         self.ts = ts;
         let w = ChannelEvents::Events(Box::new(item) as _);
         let w = sitem_data(w);
+        eprintln!("make_batch {w:?}");
         w
     }
 }

streams/src/test/timebin.rs

@@ -172,8 +172,10 @@ fn time_bin_02() -> Result<(), Error> {
                 break;
             }
         }
+        let event_range = binned_range.binned_range_time().full_range();
+        let series_range = SeriesRange::TimeRange(event_range);
         // TODO the test stream must be able to generate also one-before (on demand) and RangeComplete (by default).
-        let stream = GenerateI32::new(0, 1, range);
+        let stream = GenerateI32::new(0, 1, series_range);
         // TODO apply first some box dyn EventTransform which later is provided by TransformQuery.
         // Then the Merge will happen always by default for backends where this is needed.
         // TODO then apply the transform chain for the after-merged-stream.
@@ -189,17 +191,20 @@ fn time_bin_02() -> Result<(), Error> {
         // From there on it should no longer be neccessary to distinguish whether its still events or time bins.
         // Then, optionally collect for output type like json, or stream as batches.
         // TODO the timebinner should already provide batches to make this efficient.
-        while let Some(e) = binned_stream.next().await {
-            eprintln!("see item {e:?}");
-            let x = on_sitemty_data!(e, |e| {
-                //
-                Ok(StreamItem::DataItem(RangeCompletableItem::Data(e)))
-            });
+        if false {
+            while let Some(e) = binned_stream.next().await {
+                eprintln!("see item {e:?}");
+                let x = on_sitemty_data!(e, |e| {
+                    //
+                    Ok(StreamItem::DataItem(RangeCompletableItem::Data(e)))
+                });
+            }
+        } else {
+            let res = collect(binned_stream, deadline, 200, None, Some(binned_range)).await?;
+            let d = res.to_json_result()?.to_json_bytes()?;
+            let s = String::from_utf8_lossy(&d);
+            eprintln!("{s}");
         }
-        /*let res = collect(binned_stream, deadline, 200, None, Some(binned_range)).await?;
-        let d = res.to_json_result()?.to_json_bytes()?;
-        let s = String::from_utf8_lossy(&d);
-        eprintln!("{s}");*/
         Ok(())
     };
     runfut(fut)

streams/src/timebin.rs

@@ -192,16 +192,16 @@ where
                         }
                     },
                     Ready(None) => {
-                        trace2!("finish up");
+                        trace!("finish up");
                         let self_range_complete = self.range_complete;
                         if let Some(binner) = self.binner.as_mut() {
-                            trace2!("bins ready count before finish {}", binner.bins_ready_count());
+                            trace!("bins ready count before finish {}", binner.bins_ready_count());
                             // TODO rework the finish logic
                             if self_range_complete {
                                 binner.set_range_complete();
                             }
                             binner.push_in_progress(false);
-                            trace2!("bins ready count after finish  {}", binner.bins_ready_count());
+                            trace!("bins ready count after finish  {}", binner.bins_ready_count());
                             if binner.bins_ready_count() > 0 {
                                 if let Some(bins) = binner.bins_ready() {
                                     self.done_data = true;
@@ -226,7 +226,7 @@ where
                                 }
                             }
                         } else {
-                            trace2!("input stream finished, still no binner");
+                            trace!("input stream finished, still no binner");
                             self.done_data = true;
                             continue;
                         }