test a couple of pending points; no benefit to coverage stats though

Author: cammeresi

NOTES.md

@@ -0,0 +1,9 @@
+### Coverage anomalies
+
+Analysis with the `#[coverage(off)]` attribute in Rust nightly has
+revealed that the coverage anomalies are:
+
+- `<Normalize<S, F> as Stream>::poll_next (two regions)`
+- `<Filter<S, F> as Stream>::poll_next (two regions)`
+- `<RecordStream<S> as Stream>::poll_next (one region)`
+

README.md

@@ -98,7 +98,7 @@ verified by both `cargo llvm-cov` and codecov.io (badge at top).
 The report from `cargo llvm-cov` contains a few exceptions in its summary
 data only (5 out of over 3900 regions), but it does not positively
 identify any expression in this crate that is not executed by a test.
-These anomalies are probably small bits of code from the standard library
+These anomalies may be small bits of code from the standard library
 that are inlined by the compiler and that are thus out of the control
 of this crate.
 

src/filter/mod.rs

@@ -33,7 +33,8 @@ where
                 Poll::Ready(Some(Ok(record)))
             }
             Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(e))),
-            res => res,
+            Poll::Ready(None) => Poll::Ready(None),
+            Poll::Pending => Poll::Pending,
         }
     }
 }
@@ -77,7 +78,8 @@ where
                     }
                 }
                 Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e))),
-                res => return res,
+                Poll::Ready(None) => return Poll::Ready(None),
+                Poll::Pending => return Poll::Pending,
             }
         }
     }

src/filter/test.rs

@@ -127,6 +127,20 @@ async fn normalize_band_no_band() {
     assert!(record.get(":band").is_none());
 }
 
+#[tokio::test]
+async fn trickle_normalize_band() {
+    let stream =
+        RecordStream::new("<band:3>20m<eor><band:3>40M<eor>".as_bytes(), true);
+    let trickled = TrickleStream::new(stream);
+    let mut normalized = normalize_band(trickled);
+
+    let rec = next(&mut normalized).await;
+    assert_eq!(rec.get(":band").unwrap().as_str(), "20M");
+
+    let rec = next(&mut normalized).await;
+    assert_eq!(rec.get(":band").unwrap().as_str(), "40M");
+}
+
 #[tokio::test]
 async fn normalize_times_typed() {
     let record =
@@ -284,6 +298,20 @@ async fn exclude_callsigns_missing_call() {
     assert!(filtered.next().await.is_none());
 }
 
+#[tokio::test]
+async fn trickle_exclude_callsigns() {
+    let stream = RecordStream::new(
+        "<call:4>W1AW<eor><call:5>AB9BH<eor><call:4>W6RQ<eor>".as_bytes(),
+        true,
+    );
+    let trickled = TrickleStream::new(stream);
+    let mut filtered = exclude_callsigns(trickled, &["W1AW", "W6RQ"]);
+
+    let rec = next(&mut filtered).await;
+    assert_eq!(rec.get("call").unwrap().as_str(), "AB9BH");
+    assert!(filtered.next().await.is_none());
+}
+
 #[tokio::test]
 async fn exclude_header_removes_header() {
     let stream = RecordStream::new(

src/parse/mod.rs

@@ -330,9 +330,8 @@ where
             match Pin::new(&mut self.stream).poll_next(cx) {
                 Poll::Ready(Some(Ok(Tag::Eoh))) => return self.make(true),
                 Poll::Ready(Some(Ok(Tag::Eor))) => return self.make(false),
-                Poll::Ready(Some(Ok(Tag::Field(field)))) => {
-                    if let Err(e) = self.record.insert(field.name, field.value)
-                    {
+                Poll::Ready(Some(Ok(Tag::Field(f)))) => {
+                    if let Err(e) = self.record.insert(f.name, f.value) {
                         return Poll::Ready(Some(Err(e)));
                     }
                 }

src/parse/test.rs

@@ -1,11 +1,7 @@
 use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
-use futures::{Stream, StreamExt};
+use futures::StreamExt;
 use rust_decimal::Decimal;
-use std::io;
-use std::pin::Pin;
 use std::str::FromStr;
-use std::task::{Context, Poll};
-use tokio::io::AsyncRead;
 
 use super::*;
 use crate::test::helpers::*;
@@ -243,48 +239,6 @@ async fn complete_tag_no_error() {
     no_tags(&mut f).await;
 }
 
-struct TrickleReader {
-    data: Vec<u8>,
-    pos: usize,
-    chunk: usize,
-    delayed: bool,
-}
-
-impl TrickleReader {
-    fn new(data: &str, chunk: usize) -> Self {
-        Self {
-            data: data.as_bytes().to_vec(),
-            pos: 0,
-            chunk,
-            delayed: false,
-        }
-    }
-}
-
-impl AsyncRead for TrickleReader {
-    fn poll_read(
-        mut self: Pin<&mut Self>, cx: &mut Context<'_>,
-        buf: &mut tokio::io::ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        let remaining = self.data.len() - self.pos;
-        if remaining == 0 {
-            return Poll::Ready(Ok(()));
-        }
-
-        if !self.delayed {
-            self.delayed = true;
-            cx.waker().wake_by_ref();
-            return Poll::Pending;
-        }
-
-        let to_read = remaining.min(self.chunk).min(buf.remaining());
-        buf.put_slice(&self.data[self.pos..self.pos + to_read]);
-        self.pos += to_read;
-        self.delayed = false;
-        Poll::Ready(Ok(()))
-    }
-}
-
 async fn try_trickle_tags(chunk: usize) {
     let reader =
         TrickleReader::new("Foo <bar:3>baz <qux:5:n>12345 <eoh>   ", chunk);
@@ -320,40 +274,6 @@ async fn trickle_invalid() {
     assert_eq!(err, invalid_format("foo:3:n", 1, 1, 0));
 }
 
-struct TrickleStream<S> {
-    inner: S,
-    delayed: bool,
-}
-
-impl<S> TrickleStream<S> {
-    fn new(inner: S) -> Self {
-        Self {
-            inner,
-            delayed: false,
-        }
-    }
-}
-
-impl<S> Stream for TrickleStream<S>
-where
-    S: Stream + Unpin,
-{
-    type Item = S::Item;
-
-    fn poll_next(
-        mut self: Pin<&mut Self>, cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        if !self.delayed {
-            self.delayed = true;
-            cx.waker().wake_by_ref();
-            return Poll::Pending;
-        }
-
-        self.delayed = false;
-        Pin::new(&mut self.inner).poll_next(cx)
-    }
-}
-
 #[tokio::test]
 async fn trickle_records() {
     let reader = TrickleReader::new("<foo:3>abc<eor><foo:4>defg<eor>", 1);

src/test.rs

@@ -4,41 +4,9 @@ use chrono::{NaiveDate, NaiveTime};
 use rust_decimal::Decimal;
 
 use super::*;
-use helpers::*;
 
-pub(crate) mod helpers {
-    use std::borrow::Cow;
-
-    use super::*;
-
-    pub(crate) fn invalid_format(
-        message: &'static str, line: usize, column: usize, byte: usize,
-    ) -> Error {
-        Error::InvalidFormat {
-            message: Cow::Borrowed(message),
-            position: Position { line, column, byte },
-        }
-    }
-
-    pub(crate) fn partial_data(
-        line: usize, column: usize, byte: usize,
-    ) -> Error {
-        invalid_format("partial data at end of stream", line, column, byte)
-    }
-
-    pub(crate) fn duplicate_key(key: &str, record: Record) -> Error {
-        Error::DuplicateKey {
-            key: key.to_string(),
-            record,
-        }
-    }
-
-    pub(crate) fn cannot_output(
-        typ: &'static str, reason: &'static str,
-    ) -> Error {
-        Error::CannotOutput { typ, reason }
-    }
-}
+pub(crate) mod helpers;
+use helpers::*;
 
 #[test]
 fn tag_as_field_returns_some_for_field() {

src/test/helpers.rs

@@ -0,0 +1,108 @@
+use std::borrow::Cow;
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use futures::Stream;
+use tokio::io::{AsyncRead, ReadBuf};
+
+use crate::{Error, Position, Record};
+
+pub(crate) fn invalid_format(
+    message: &'static str, line: usize, column: usize, byte: usize,
+) -> Error {
+    Error::InvalidFormat {
+        message: Cow::Borrowed(message),
+        position: Position { line, column, byte },
+    }
+}
+
+pub(crate) fn partial_data(line: usize, column: usize, byte: usize) -> Error {
+    invalid_format("partial data at end of stream", line, column, byte)
+}
+
+pub(crate) fn duplicate_key(key: &str, record: Record) -> Error {
+    Error::DuplicateKey {
+        key: key.to_string(),
+        record,
+    }
+}
+
+pub(crate) fn cannot_output(typ: &'static str, reason: &'static str) -> Error {
+    Error::CannotOutput { typ, reason }
+}
+
+pub(crate) struct TrickleReader {
+    data: Vec<u8>,
+    pos: usize,
+    chunk: usize,
+    delayed: bool,
+}
+
+impl TrickleReader {
+    pub(crate) fn new(data: &str, chunk: usize) -> Self {
+        Self {
+            data: data.as_bytes().to_vec(),
+            pos: 0,
+            chunk,
+            delayed: false,
+        }
+    }
+}
+
+impl AsyncRead for TrickleReader {
+    fn poll_read(
+        mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let remaining = self.data.len() - self.pos;
+        if remaining == 0 {
+            return Poll::Ready(Ok(()));
+        }
+
+        if !self.delayed {
+            self.delayed = true;
+            cx.waker().wake_by_ref();
+            return Poll::Pending;
+        }
+
+        let to_read = remaining.min(self.chunk).min(buf.remaining());
+        buf.put_slice(&self.data[self.pos..self.pos + to_read]);
+        self.pos += to_read;
+        self.delayed = false;
+        Poll::Ready(Ok(()))
+    }
+}
+
+pub(crate) struct TrickleStream<S> {
+    inner: S,
+    delayed: bool,
+}
+
+impl<S> TrickleStream<S> {
+    pub(crate) fn new(inner: S) -> Self {
+        Self {
+            inner,
+            delayed: false,
+        }
+    }
+}
+
+impl<S> Stream for TrickleStream<S>
+where
+    S: Stream + Unpin,
+{
+    type Item = S::Item;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>, cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        if !self.delayed {
+            self.delayed = true;
+            cx.waker().wake_by_ref();
+            return Poll::Pending;
+        }
+
+        self.delayed = false;
+        Pin::new(&mut self.inner).poll_next(cx)
+    }
+}