Exclude tests from coverage report

quirky_binder/Cargo.toml

@@ -27,3 +27,6 @@ syn = { version = "1", features = ["full", "extra-traits"] }
 thiserror = "1"
 truc = "0.2"
 which = "4"
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage,coverage_nightly)'] }

quirky_binder/src/drawing/graph.rs

@@ -1,10 +1,12 @@
+use std::collections::{btree_map::Entry, BTreeMap};
+
+use truc::record::definition::{DatumId, RecordVariantId};
+
 use super::{
     Drawing, DrawingColumn, DrawingEdge, DrawingNode, DrawingPort, DrawingPortAlign,
     DrawingPortSize, DrawingPortsColumn,
 };
 use crate::prelude::*;
-use std::collections::{btree_map::Entry, BTreeMap};
-use truc::record::definition::{DatumId, RecordVariantId};
 
 const COLORS: [&str; 20] = [
     "#e6194B", "#3cb44b", "#ffe119", "#4363d8", "#f58231", "#911eb4", "#42d4f4", "#f032e6",

quirky_binder/src/drawing/mod.rs

@@ -1,6 +1,7 @@
-use crate::prelude::*;
 use std::collections::BTreeMap;
 
+use crate::prelude::*;
+
 pub mod graph;
 
 #[derive(Debug)]

quirky_binder/src/filter/accumulate.rs

@@ -1,6 +1,7 @@
-use crate::prelude::*;
 use truc::record::type_resolver::TypeResolver;
 
+use crate::prelude::*;
+
 #[derive(Getters)]
 pub struct Accumulate {
     name: FullyQualifiedName,

quirky_binder/src/filter/transform/string.rs

@@ -2,11 +2,11 @@ use proc_macro2::TokenStream;
 use serde::Deserialize;
 use truc::record::type_resolver::TypeResolver;
 
+use super::{
+    SubTransform, SubTransformParams, SubTransformSpec, Transform, TransformParams, TransformSpec,
+};
 use crate::prelude::*;
 
-use super::{SubTransform, SubTransformParams, SubTransformSpec};
-use super::{Transform, TransformParams, TransformSpec};
-
 #[derive(Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct TransformStringParams<'a> {

quirky_binder/src/lib.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+
 #[macro_use]
 extern crate derive_more;
 #[macro_use]

quirky_binder/src/stream.rs

@@ -1,11 +1,13 @@
-use crate::prelude::*;
-use itertools::Itertools;
 use std::{
     collections::{BTreeMap, BTreeSet},
     ops::Deref,
 };
+
+use itertools::Itertools;
 use truc::record::definition::{DatumId, RecordVariantId};
 
+use crate::prelude::*;
+
 /// Defines the type of records going through a given stream.
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Hash, Default, Display, Debug, From)]
 pub struct StreamRecordType(FullyQualifiedName);

quirky_binder/src/support/cmp.rs

@@ -146,8 +146,9 @@ where
 }
 
 #[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {
-    use super::{fields_cmp, fields_cmp_ab, Directed};
+    use super::*;
 
     #[test]
     fn test_fields_cmp_1() {

quirky_binder/src/support/eq.rs

@@ -63,8 +63,9 @@ where
 }
 
 #[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {
-    use super::{fields_eq, fields_eq_ab};
+    use super::*;
 
     #[test]
     fn test_fields_eq_1() {

quirky_binder_lang/Cargo.toml

@@ -31,3 +31,6 @@ antinom = { git = "https://github.com/arnodb/antinom.git" }
 assert_matches = "1"
 rand_chacha = { version = "0.3" }
 rstest = "0.18.2"
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage,coverage_nightly)'] }

quirky_binder_lang/src/lib.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+
 #[cfg(test)]
 #[macro_use]
 extern crate assert_matches;

quirky_binder_lang/src/parser/crafted_impl/lexer.rs

@@ -182,11 +182,12 @@ pub fn lexer(input: &str) -> Lexer<impl Iterator<Item = Token>> {
 }
 
 #[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {
     use logos::{Logos, Span};
     use rstest::rstest;
 
-    use super::Token;
+    use super::*;
 
     #[rstest]
     #[case(r#"'\''"#, vec![(Ok(Token::QuotedChar(r#"'\''"#)), 0..4)])]

quirky_binder_lang/src/parser/crafted_impl/mod.rs

@@ -697,6 +697,7 @@ where
 }
 
 #[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {
     use rstest::rstest;
 

quirky_binder_lang/src/parser/mod.rs

@@ -146,4 +146,5 @@ fn assemble_inputs<'a>(
 pub mod fuzzer;
 
 #[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod fuzz_tests;

quirky_binder_lang/src/parser/nom_impl.rs

@@ -557,6 +557,7 @@ where
 }
 
 #[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {
     use rstest::rstest;
 

quirky_binder_support/Cargo.toml

@@ -27,3 +27,6 @@ assert_matches = "1"
 rand = "0.8"
 rand_chacha = { version = "0.3" }
 rstest = "0.18.2"
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage,coverage_nightly)'] }

quirky_binder_support/src/data/buffer.rs

@@ -69,24 +69,30 @@ impl BufferReader {
     }
 }
 
-#[test]
-fn test_memory() {
-    let mut buffer = Buffer::with_max_size_in_memory(1024 * 1024);
-    buffer.push("universe").unwrap();
-    buffer.push(42).unwrap();
-    let mut reader = buffer.end_writing().unwrap();
-    assert_eq!(reader.read::<String>().unwrap(), "universe");
-    assert_eq!(reader.read::<i32>().unwrap(), 42);
-    reader.end_reading().unwrap();
-}
+#[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_memory() {
+        let mut buffer = Buffer::with_max_size_in_memory(1024 * 1024);
+        buffer.push("universe").unwrap();
+        buffer.push(42).unwrap();
+        let mut reader = buffer.end_writing().unwrap();
+        assert_eq!(reader.read::<String>().unwrap(), "universe");
+        assert_eq!(reader.read::<i32>().unwrap(), 42);
+        reader.end_reading().unwrap();
+    }
 
-#[test]
-fn test_rolled() {
-    let mut buffer = Buffer::with_max_size_in_memory(1);
-    buffer.push("universe").unwrap();
-    buffer.push(42).unwrap();
-    let mut reader = buffer.end_writing().unwrap();
-    assert_eq!(reader.read::<String>().unwrap(), "universe");
-    assert_eq!(reader.read::<i32>().unwrap(), 42);
-    reader.end_reading().unwrap();
+    #[test]
+    fn test_rolled() {
+        let mut buffer = Buffer::with_max_size_in_memory(1);
+        buffer.push("universe").unwrap();
+        buffer.push(42).unwrap();
+        let mut reader = buffer.end_writing().unwrap();
+        assert_eq!(reader.read::<String>().unwrap(), "universe");
+        assert_eq!(reader.read::<i32>().unwrap(), 42);
+        reader.end_reading().unwrap();
+    }
 }

quirky_binder_support/src/iterator/accumulate.rs

@@ -94,36 +94,42 @@ impl State {
     }
 }
 
-#[test]
-fn should_accumulate_stream() {
-    #[derive(Debug)]
-    enum Error {
-        Bincode(bincode::Error),
-    }
+#[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod tests {
+    use super::*;
 
-    impl From<bincode::Error> for Error {
-        fn from(err: bincode::Error) -> Self {
-            Self::Bincode(err)
+    #[test]
+    fn should_accumulate_stream() {
+        #[derive(Debug)]
+        enum Error {
+            Bincode(bincode::Error),
+        }
+
+        impl From<bincode::Error> for Error {
+            fn from(err: bincode::Error) -> Self {
+                Self::Bincode(err)
+            }
         }
-    }
 
-    let mut stream = Accumulate::new(fallible_iterator::convert(
-        [
-            "ZZZ".to_owned(),
-            "".to_owned(),
-            "a".to_owned(),
-            "z".to_owned(),
-            "A".to_owned(),
-        ]
-        .into_iter()
-        .map(Ok::<_, Error>),
-    ));
-    assert_matches!(stream.next(), Ok(Some(v)) if v == "ZZZ");
-    assert_matches!(stream.next(), Ok(Some(v)) if v == "");
-    assert_matches!(stream.next(), Ok(Some(v)) if v == "a");
-    assert_matches!(stream.next(), Ok(Some(v)) if v == "z");
-    assert_matches!(stream.next(), Ok(Some(v)) if v == "A");
-    // End of stream
-    assert_matches!(stream.next(), Ok(None));
-    assert_matches!(stream.next(), Ok(None));
+        let mut stream = Accumulate::new(fallible_iterator::convert(
+            [
+                "ZZZ".to_owned(),
+                "".to_owned(),
+                "a".to_owned(),
+                "z".to_owned(),
+                "A".to_owned(),
+            ]
+            .into_iter()
+            .map(Ok::<_, Error>),
+        ));
+        assert_matches!(stream.next(), Ok(Some(v)) if v == "ZZZ");
+        assert_matches!(stream.next(), Ok(Some(v)) if v == "");
+        assert_matches!(stream.next(), Ok(Some(v)) if v == "a");
+        assert_matches!(stream.next(), Ok(Some(v)) if v == "z");
+        assert_matches!(stream.next(), Ok(Some(v)) if v == "A");
+        // End of stream
+        assert_matches!(stream.next(), Ok(None));
+        assert_matches!(stream.next(), Ok(None));
+    }
 }

quirky_binder_support/src/iterator/dedup.rs

@@ -101,20 +101,26 @@ where
     }
 }
 
-#[test]
-fn should_dedup_stream() {
-    let mut stream = Dedup::new(
-        fallible_iterator::convert(
-            [("a", 12), ("a", 12), ("a", 42), ("b", 42)]
-                .into_iter()
-                .map(Ok::<_, ()>),
-        ),
-        |a, b| (&a.0).eq(&b.0) && a.1.eq(&b.1),
-    );
-    assert_matches!(stream.next(), Ok(Some((v, 12))) if v == "a");
-    assert_matches!(stream.next(), Ok(Some((v, 42))) if v == "a");
-    assert_matches!(stream.next(), Ok(Some((v, 42))) if v == "b");
-    // End of stream
-    assert_matches!(stream.next(), Ok(None));
-    assert_matches!(stream.next(), Ok(None));
+#[cfg(test)]
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_dedup_stream() {
+        let mut stream = Dedup::new(
+            fallible_iterator::convert(
+                [("a", 12), ("a", 12), ("a", 42), ("b", 42)]
+                    .into_iter()
+                    .map(Ok::<_, ()>),
+            ),
+            |a, b| (&a.0).eq(&b.0) && a.1.eq(&b.1),
+        );
+        assert_matches!(stream.next(), Ok(Some((v, 12))) if v == "a");
+        assert_matches!(stream.next(), Ok(Some((v, 42))) if v == "a");
+        assert_matches!(stream.next(), Ok(Some((v, 42))) if v == "b");
+        // End of stream
+        assert_matches!(stream.next(), Ok(None));
+        assert_matches!(stream.next(), Ok(None));
+    }
 }