portable-network-archive 0.32.2

Portable-Network-Archive cli
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use std::str::FromStr;

#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub(crate) struct Argon2idParams {
    pub(crate) time: Option<u32>,
    pub(crate) memory: Option<u32>,
    pub(crate) parallelism: Option<u32>,
}

impl FromStr for Argon2idParams {
    type Err = String;

    #[inline]
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let mut time = None;
        let mut memory = None;
        let mut parallelism = None;
        for param in s.split(',') {
            let kv = param.split_once('=');
            if let Some(("t", n)) = kv {
                time = Some(
                    n.parse()
                        .map_err(|it: std::num::ParseIntError| it.to_string())?,
                )
            } else if let Some(("m", n)) = kv {
                memory = Some(
                    n.parse()
                        .map_err(|it: std::num::ParseIntError| it.to_string())?,
                )
            } else if let Some(("p", n)) = kv {
                parallelism = Some(
                    n.parse()
                        .map_err(|it: std::num::ParseIntError| it.to_string())?,
                )
            } else {
                return Err(format!("Unknown parameter `{param}`"));
            }
        }
        Ok(Self {
            time,
            memory,
            parallelism,
        })
    }
}

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

    #[test]
    fn parse_argon2id_params() {
        assert_eq!(
            Argon2idParams::from_str("t=1,m=2,p=3"),
            Ok(Argon2idParams {
                time: Some(1),
                memory: Some(2),
                parallelism: Some(3),
            })
        );
        assert_eq!(
            Argon2idParams::from_str("t=1,p=3"),
            Ok(Argon2idParams {
                time: Some(1),
                memory: None,
                parallelism: Some(3),
            })
        );
    }

    #[test]
    fn parse_argon2id_empty_params() {
        assert!(Argon2idParams::from_str("").is_err());
    }

    #[test]
    fn parse_argon2id_unknown_parms() {
        assert!(Argon2idParams::from_str("a=1").is_err());
        assert!(Argon2idParams::from_str("t=1,a=1").is_err());
    }

    #[test]
    fn parse_argon2id_invalid_parms() {
        assert!(Argon2idParams::from_str("t").is_err());
        assert!(Argon2idParams::from_str("t=").is_err());
        assert!(Argon2idParams::from_str(",").is_err());
        assert!(Argon2idParams::from_str("t=1,").is_err());
        assert!(Argon2idParams::from_str("t=x").is_err());
        assert!(Argon2idParams::from_str("m=x").is_err());
        assert!(Argon2idParams::from_str("p=x").is_err());
    }
}