Add #[coverage(off)] to Display impls

Cargo.toml

@@ -44,3 +44,8 @@ anyhow = "1.0"
 version = "0.32"
 default-features = false
 features = ["macros"]
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+# Set by cargo-llvm-cov when running on nightly
+check-cfg = ['cfg(coverage_nightly)']

src/distribution/beta.rs

@@ -36,6 +36,7 @@ pub enum BetaError {
 }
 
 impl std::fmt::Display for BetaError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             BetaError::ShapeAInvalid => write!(f, "Shape A is NaN, zero, or negative"),

src/distribution/binomial.rs

@@ -32,6 +32,7 @@ pub enum BinomialError {
 }
 
 impl std::fmt::Display for BinomialError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             BinomialError::ProbabilityInvalid => write!(f, "Probability is NaN or not in [0, 1]"),

src/distribution/categorical.rs

@@ -39,6 +39,7 @@ pub enum CategoricalError {
 }
 
 impl std::fmt::Display for CategoricalError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             CategoricalError::ProbMassEmpty => write!(f, "Probability mass is empty"),

src/distribution/cauchy.rs

@@ -32,6 +32,7 @@ pub enum CauchyError {
 }
 
 impl std::fmt::Display for CauchyError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             CauchyError::LocationInvalid => write!(f, "Location is NaN"),

src/distribution/chi.rs

@@ -30,6 +30,7 @@ pub enum ChiError {
 }
 
 impl std::fmt::Display for ChiError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             ChiError::FreedomInvalid => {

src/distribution/dirac.rs

@@ -24,6 +24,7 @@ pub enum DiracError {
 }
 
 impl std::fmt::Display for DiracError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             DiracError::ValueInvalid => write!(f, "Value v is NaN"),

src/distribution/dirichlet.rs

@@ -41,6 +41,7 @@ pub enum DirichletError {
 }
 
 impl std::fmt::Display for DirichletError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             DirichletError::AlphaTooShort => write!(f, "Alpha contains less than two elements"),

src/distribution/discrete_uniform.rs

@@ -29,6 +29,7 @@ pub enum DiscreteUniformError {
 }
 
 impl std::fmt::Display for DiscreteUniformError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             DiscreteUniformError::MinMaxInvalid => write!(f, "Maximum is less than minimum"),

src/distribution/exponential.rs

@@ -31,6 +31,7 @@ pub enum ExpError {
 }
 
 impl std::fmt::Display for ExpError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             ExpError::RateInvalid => write!(f, "Rate is NaN, zero, or less than zero"),

src/distribution/fisher_snedecor.rs

@@ -35,6 +35,7 @@ pub enum FisherSnedecorError {
 }
 
 impl std::fmt::Display for FisherSnedecorError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             FisherSnedecorError::Freedom1Invalid => {

src/distribution/gamma.rs

@@ -37,6 +37,7 @@ pub enum GammaError {
 }
 
 impl std::fmt::Display for GammaError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             GammaError::ShapeInvalid => write!(f, "Shape is NaN, zero, or less than zero."),

src/distribution/geometric.rs

@@ -31,6 +31,7 @@ pub enum GeometricError {
 }
 
 impl std::fmt::Display for GeometricError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             GeometricError::ProbabilityInvalid => write!(f, "Probability is NaN or not in (0, 1]"),

src/distribution/hypergeometric.rs

@@ -26,6 +26,7 @@ pub enum HypergeometricError {
 }
 
 impl std::fmt::Display for HypergeometricError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             HypergeometricError::TooManySuccesses => write!(f, "successes > population"),

src/distribution/inverse_gamma.rs

@@ -35,6 +35,7 @@ pub enum InverseGammaError {
 }
 
 impl std::fmt::Display for InverseGammaError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             InverseGammaError::ShapeInvalid => {

src/distribution/laplace.rs

@@ -32,6 +32,7 @@ pub enum LaplaceError {
 }
 
 impl std::fmt::Display for LaplaceError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             LaplaceError::LocationInvalid => write!(f, "Location is NaN"),

src/distribution/log_normal.rs

@@ -36,6 +36,7 @@ pub enum LogNormalError {
 }
 
 impl std::fmt::Display for LogNormalError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             LogNormalError::LocationInvalid => write!(f, "Location is NaN"),

src/distribution/multinomial.rs

@@ -45,6 +45,7 @@ pub enum MultinomialError {
 }
 
 impl std::fmt::Display for MultinomialError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             MultinomialError::NotEnoughProbabilities => write!(f, "Fewer than two probabilities"),

src/distribution/multivariate_normal.rs

@@ -125,6 +125,7 @@ pub enum MultivariateNormalError {
 }
 
 impl std::fmt::Display for MultivariateNormalError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             MultivariateNormalError::CovInvalid => {

src/distribution/multivariate_students_t.rs

@@ -59,6 +59,7 @@ pub enum MultivariateStudentError {
 }
 
 impl std::fmt::Display for MultivariateStudentError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             MultivariateStudentError::ScaleInvalid => {

src/distribution/negative_binomial.rs

@@ -50,6 +50,7 @@ pub enum NegativeBinomialError {
 }
 
 impl std::fmt::Display for NegativeBinomialError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             NegativeBinomialError::RInvalid => write!(f, "r is NaN or less than zero"),

src/distribution/normal.rs

@@ -34,6 +34,7 @@ pub enum NormalError {
 }
 
 impl std::fmt::Display for NormalError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             NormalError::MeanInvalid => write!(f, "Mean is NaN"),

src/distribution/pareto.rs

@@ -34,6 +34,7 @@ pub enum ParetoError {
 }
 
 impl std::fmt::Display for ParetoError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             ParetoError::ScaleInvalid => write!(f, "Scale is NaN, zero, or less than zero"),

src/distribution/poisson.rs

@@ -30,6 +30,7 @@ pub enum PoissonError {
 }
 
 impl std::fmt::Display for PoissonError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             PoissonError::LambdaInvalid => write!(f, "Lambda is NaN, zero, or less than zero"),

src/distribution/students_t.rs

@@ -38,6 +38,7 @@ pub enum StudentsTError {
 }
 
 impl std::fmt::Display for StudentsTError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             StudentsTError::LocationInvalid => write!(f, "Location is NaN"),

src/distribution/triangular.rs

@@ -43,6 +43,7 @@ pub enum TriangularError {
 }
 
 impl std::fmt::Display for TriangularError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             TriangularError::MinInvalid => write!(f, "Minimum is NaN or infinite."),

src/distribution/uniform.rs

@@ -38,6 +38,7 @@ pub enum UniformError {
 }
 
 impl std::fmt::Display for UniformError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             UniformError::MinInvalid => write!(f, "Minimum is NaN or infinite"),

src/distribution/weibull.rs

@@ -37,6 +37,7 @@ pub enum WeibullError {
 }
 
 impl std::fmt::Display for WeibullError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             WeibullError::ShapeInvalid => write!(f, "Shape is NaN, zero, or less than zero."),

src/lib.rs

@@ -48,6 +48,7 @@
 #![allow(clippy::excessive_precision)]
 #![allow(clippy::many_single_char_names)]
 #![forbid(unsafe_code)]
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
 
 #[macro_use]
 extern crate approx;

src/stats_tests/fisher.rs

@@ -104,6 +104,7 @@ pub enum FishersExactTestError {
 }
 
 impl std::fmt::Display for FishersExactTestError {
+    #[cfg_attr(coverage_nightly, coverage(off))]
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             FishersExactTestError::TableInvalidForHypergeometric(hg_err) => {