Debian Codegraph @

.cargo/vendor/nom/tests/float.rs

raw
1 use nom::branch::alt;
2 use nom::bytes::complete::tag;
3 use nom::character::streaming::digit1 as digit;
4 use nom::combinator::{map, map_res, opt, recognize};
5 use nom::error::ErrorKind;
6 use nom::number::complete::f32;
7 use nom::number::complete::f64;
8 use nom::number::Endianness;
9 use nom::sequence::{delimited, pair};
10 use nom::Err;
11 use nom::{IResult, Parser};
12 use std::str;
13 use std::str::FromStr;
14
15 fn unsigned_float(i: &[u8]) -> IResult<&[u8], f32> {
16 let float_bytes = recognize(alt((
17 delimited(digit, tag("."), opt(digit)),
18 delimited(opt(digit), tag("."), digit),
19 )));
20 let float_str = map_res(float_bytes, str::from_utf8);
21 map_res(float_str, FromStr::from_str).parse(i)
22 }
23
24 fn float(i: &[u8]) -> IResult<&[u8], f32> {
25 map(
26 pair(opt(alt((tag("+"), tag("-")))), unsigned_float),
27 |(sign, value)| {
28 sign
29 .and_then(|s| if s[0] == b'-' { Some(-1f32) } else { None })
30 .unwrap_or(1f32)
31 * value
32 },
33 )
34 .parse(i)
35 }
36
37 #[test]
38 fn unsigned_float_test() {
39 assert_eq!(unsigned_float(&b"123.456;"[..]), Ok((&b";"[..], 123.456)));
40 assert_eq!(unsigned_float(&b"0.123;"[..]), Ok((&b";"[..], 0.123)));
41 assert_eq!(unsigned_float(&b"123.0;"[..]), Ok((&b";"[..], 123.0)));
42 assert_eq!(unsigned_float(&b"123.;"[..]), Ok((&b";"[..], 123.0)));
43 assert_eq!(unsigned_float(&b".123;"[..]), Ok((&b";"[..], 0.123)));
44 }
45
46 #[test]
47 fn float_test() {
48 assert_eq!(float(&b"123.456;"[..]), Ok((&b";"[..], 123.456)));
49 assert_eq!(float(&b"+123.456;"[..]), Ok((&b";"[..], 123.456)));
50 assert_eq!(float(&b"-123.456;"[..]), Ok((&b";"[..], -123.456)));
51 }
52
53 #[test]
54 fn test_f32_big_endian() {
55 let be_f32 = |s| f32::<_, (_, ErrorKind)>(Endianness::Big)(s);
56
57 assert_eq!(
58 be_f32(&[0x41, 0x48, 0x00, 0x00][..]),
59 Ok((&[] as &[u8], 12.5))
60 );
61 }
62
63 #[test]
64 fn test_f32_little_endian() {
65 let le_f32 = |s| f32::<_, (_, ErrorKind)>(Endianness::Little)(s);
66
67 assert_eq!(
68 le_f32(&[0x00, 0x00, 0x48, 0x41][..]),
69 Ok((&[] as &[u8], 12.5))
70 );
71 }
72
73 #[test]
74 fn test_f64_big_endian() {
75 let be_f64 = |s| f64::<&[u8], (&[u8], ErrorKind)>(Endianness::Big)(s);
76
77 let input = &[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..];
78 let expected = 12.5f64;
79 match be_f64(input) {
80 Ok((rest, value)) => {
81 assert!(rest.is_empty());
82 assert_eq!(value, expected);
83 }
84 Err(_) => assert!(false, "Failed to parse big-endian f64"),
85 }
86
87 let incomplete_input = &b"abc"[..];
88 assert!(matches!(be_f64(incomplete_input), Err(Err::Error(_))));
89 }
90
91 #[test]
92 fn test_f64_little_endian() {
93 let le_f64 = |s| f64::<&[u8], (&[u8], ErrorKind)>(Endianness::Little)(s);
94
95 let input = &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..];
96 let expected = 12.5f64;
97 match le_f64(input) {
98 Ok((rest, value)) => {
99 assert!(rest.is_empty());
100 assert_eq!(value, expected);
101 }
102 Err(_) => assert!(false, "Failed to parse little-endian f64"),
103 }
104
105 let incomplete_input = &b"abc"[..];
106 assert!(matches!(le_f64(incomplete_input), Err(Err::Error(_))));
107 }