pavan 1.1.0

Pavan — aerodynamics engine for atmosphere, airfoils, panel methods, VLM, compressible flow, stability, propulsion, and CFD
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use thiserror::Error;

#[derive(Debug, Error)]
#[non_exhaustive]
pub enum PavanError {
    #[error("invalid angle: {0}")]
    InvalidAngle(String),
    #[error("invalid altitude: {0}")]
    InvalidAltitude(String),
    #[error("invalid velocity: {0}")]
    InvalidVelocity(String),
    #[error("invalid geometry: {0}")]
    InvalidGeometry(String),
    #[error("computation error: {0}")]
    ComputationError(String),
}

pub type Result<T> = std::result::Result<T, PavanError>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn error_display() {
        let e = PavanError::InvalidAltitude("too high".into());
        assert!(e.to_string().contains("too high"));
    }

    #[test]
    fn result_type() {
        let ok: Result<f64> = Ok(1.0);
        assert!(ok.is_ok());
    }

    #[test]
    fn all_variants_display() {
        let cases: Vec<PavanError> = vec![
            PavanError::InvalidAngle("bad angle".into()),
            PavanError::InvalidAltitude("too high".into()),
            PavanError::InvalidVelocity("negative".into()),
            PavanError::InvalidGeometry("zero area".into()),
            PavanError::ComputationError("diverged".into()),
        ];
        let prefixes = [
            "invalid angle",
            "invalid altitude",
            "invalid velocity",
            "invalid geometry",
            "computation error",
        ];
        for (e, prefix) in cases.iter().zip(prefixes.iter()) {
            let msg = e.to_string();
            assert!(
                msg.starts_with(prefix),
                "expected prefix '{prefix}', got '{msg}'"
            );
        }
    }

    #[test]
    fn error_is_send_sync() {
        fn assert_send_sync<T: Send + Sync>() {}
        assert_send_sync::<PavanError>();
    }

    #[test]
    fn result_err_variant() {
        let err: Result<f64> = Err(PavanError::ComputationError("nan".into()));
        assert!(err.is_err());
        let Err(e) = err else { unreachable!() };
        assert!(matches!(e, PavanError::ComputationError(_)));
    }
}