Refactor remote stream decode

daqbufp2/src/test.rs

@@ -8,14 +8,54 @@ pub mod binnedjson;
 #[cfg(test)]
 mod events;
 #[cfg(test)]
-mod eventsjson;
-#[cfg(test)]
 mod timeweightedjson;
 
 use bytes::BytesMut;
 use err::Error;
 use std::future::Future;
 
+fn f32_iter_cmp_near<A, B>(a: A, b: B) -> bool
+where
+    A: IntoIterator<Item = f32>,
+    B: IntoIterator<Item = f32>,
+{
+    let mut a = a.into_iter();
+    let mut b = b.into_iter();
+    loop {
+        let x = a.next();
+        let y = b.next();
+        if let (Some(x), Some(y)) = (x, y) {
+            let x = {
+                let mut a = x.to_ne_bytes();
+                a[0] &= 0xf0;
+                f32::from_ne_bytes(a)
+            };
+            let y = {
+                let mut a = y.to_ne_bytes();
+                a[0] &= 0xf0;
+                f32::from_ne_bytes(a)
+            };
+            if x != y {
+                return false;
+            }
+        } else if x.is_some() || y.is_some() {
+            return false;
+        } else {
+            return true;
+        }
+    }
+}
+
+#[test]
+fn test_f32_iter_cmp_near() {
+    let a = [-127.553e17];
+    let b = [-127.554e17];
+    assert_eq!(f32_iter_cmp_near(a, b), false);
+    let a = [-127.55300e17];
+    let b = [-127.55301e17];
+    assert_eq!(f32_iter_cmp_near(a, b), true);
+}
+
 fn run_test<F>(f: F) -> Result<(), Error>
 where
     F: Future<Output = Result<(), Error>> + Send,

daqbufp2/src/test/api4.rs

@@ -0,0 +1 @@
+pub mod eventsjson;

daqbufp2/src/test/api4/eventsjson.rs

@@ -1,5 +1,6 @@
 use crate::err::ErrConv;
 use crate::nodes::require_test_hosts_running;
+use crate::test::f32_iter_cmp_near;
 use chrono::{DateTime, Utc};
 use err::Error;
 use http::StatusCode;
@@ -34,6 +35,62 @@ fn events_plain_json_00() -> Result<(), Error> {
     taskrun::run(fut)
 }
 
+#[test]
+fn events_plain_json_01() -> Result<(), Error> {
+    let fut = async {
+        let rh = require_test_hosts_running()?;
+        let cluster = &rh.cluster;
+        let jsv = events_plain_json(
+            Channel {
+                backend: "test-disk-databuffer".into(),
+                name: "scalar-i32-be".into(),
+                series: None,
+            },
+            "1970-01-01T00:20:10.000Z",
+            "1970-01-01T00:20:13.000Z",
+            cluster,
+            true,
+            4,
+        )
+        .await?;
+        let res: items_2::eventsdim0::EventsDim0CollectorOutput<i32> = serde_json::from_value(jsv).unwrap();
+        assert_eq!(res.ts_anchor_sec(), 1210);
+        assert_eq!(res.pulse_anchor(), 2420);
+        let exp = [2420., 2421., 2422., 2423., 2424., 2425.];
+        assert_eq!(f32_iter_cmp_near(res.values_to_f32(), exp), true);
+        assert_eq!(res.range_complete(), true);
+        assert_eq!(res.timed_out(), false);
+        Ok(())
+    };
+    taskrun::run(fut)
+}
+
+#[test]
+fn events_plain_json_02_range_incomplete() -> Result<(), Error> {
+    let fut = async {
+        let rh = require_test_hosts_running()?;
+        let cluster = &rh.cluster;
+        let jsv = events_plain_json(
+            Channel {
+                backend: "test-disk-databuffer".into(),
+                name: "scalar-i32-be".into(),
+                series: None,
+            },
+            "1970-01-03T23:59:55.000Z",
+            "1970-01-04T00:00:01.000Z",
+            cluster,
+            true,
+            4,
+        )
+        .await?;
+        let res: items_2::eventsdim0::EventsDim0CollectorOutput<i32> = serde_json::from_value(jsv).unwrap();
+        assert_eq!(res.range_complete(), false);
+        assert_eq!(res.timed_out(), false);
+        Ok(())
+    };
+    taskrun::run(fut)
+}
+
 // TODO improve by a more information-rich return type.
 async fn events_plain_json(
     channel: Channel,