1 use crate::{
2 Literal, ParseError,
3 test_util::{assert_parse_ok_eq, assert_roundtrip},
4 };
5 use super::{FloatLit, FloatType};
6
7
8 // ===== Utility functions =======================================================================
9
10 /// Helper macro to check parsing a float.
11 ///
12 /// This macro contains quite a bit of logic itself (which can be buggy of
13 /// course), so we have a few test functions below to test a bunch of cases
14 /// manually.
15 macro_rules! check {
16 ($intpart:literal $fracpart:literal $exppart:literal $suffix:tt) => {
17 let input = concat!($intpart, $fracpart, $exppart, check!(@stringify_suffix $suffix));
18 let expected_float = FloatLit {
19 raw: input,
20 end_integer_part: $intpart.len(),
21 end_fractional_part: $intpart.len() + $fracpart.len(),
22 end_number_part: $intpart.len() + $fracpart.len() + $exppart.len(),
23 type_suffix: check!(@ty $suffix),
24 };
25
26 assert_parse_ok_eq(
27 input, FloatLit::parse(input), expected_float.clone(), "FloatLit::parse");
28 assert_parse_ok_eq(
29 input, Literal::parse(input), Literal::Float(expected_float), "Literal::parse");
30 assert_roundtrip(expected_float.to_owned(), input);
31 };
32 (@ty f32) => { Some(FloatType::F32) };
33 (@ty f64) => { Some(FloatType::F64) };
34 (@ty -) => { None };
35 (@stringify_suffix -) => { "" };
36 (@stringify_suffix $suffix:ident) => { stringify!($suffix) };
37 }
38
39
40 // ===== Actual tests ===========================================================================
41
42 #[test]
manual_without_suffix() -> Result<(), ParseError>43 fn manual_without_suffix() -> Result<(), ParseError> {
44 let f = FloatLit::parse("3.14")?;
45 assert_eq!(f.number_part(), "3.14");
46 assert_eq!(f.integer_part(), "3");
47 assert_eq!(f.fractional_part(), Some("14"));
48 assert_eq!(f.exponent_part(), "");
49 assert_eq!(f.type_suffix(), None);
50
51 let f = FloatLit::parse("9.")?;
52 assert_eq!(f.number_part(), "9.");
53 assert_eq!(f.integer_part(), "9");
54 assert_eq!(f.fractional_part(), Some(""));
55 assert_eq!(f.exponent_part(), "");
56 assert_eq!(f.type_suffix(), None);
57
58 let f = FloatLit::parse("8e1")?;
59 assert_eq!(f.number_part(), "8e1");
60 assert_eq!(f.integer_part(), "8");
61 assert_eq!(f.fractional_part(), None);
62 assert_eq!(f.exponent_part(), "e1");
63 assert_eq!(f.type_suffix(), None);
64
65 let f = FloatLit::parse("8E3")?;
66 assert_eq!(f.number_part(), "8E3");
67 assert_eq!(f.integer_part(), "8");
68 assert_eq!(f.fractional_part(), None);
69 assert_eq!(f.exponent_part(), "E3");
70 assert_eq!(f.type_suffix(), None);
71
72 let f = FloatLit::parse("8_7_6.1_23e15")?;
73 assert_eq!(f.number_part(), "8_7_6.1_23e15");
74 assert_eq!(f.integer_part(), "8_7_6");
75 assert_eq!(f.fractional_part(), Some("1_23"));
76 assert_eq!(f.exponent_part(), "e15");
77 assert_eq!(f.type_suffix(), None);
78
79 let f = FloatLit::parse("8.2e-_04_9")?;
80 assert_eq!(f.number_part(), "8.2e-_04_9");
81 assert_eq!(f.integer_part(), "8");
82 assert_eq!(f.fractional_part(), Some("2"));
83 assert_eq!(f.exponent_part(), "e-_04_9");
84 assert_eq!(f.type_suffix(), None);
85
86 Ok(())
87 }
88
89 #[test]
manual_with_suffix() -> Result<(), ParseError>90 fn manual_with_suffix() -> Result<(), ParseError> {
91 let f = FloatLit::parse("3.14f32")?;
92 assert_eq!(f.number_part(), "3.14");
93 assert_eq!(f.integer_part(), "3");
94 assert_eq!(f.fractional_part(), Some("14"));
95 assert_eq!(f.exponent_part(), "");
96 assert_eq!(f.type_suffix(), Some(FloatType::F32));
97
98 let f = FloatLit::parse("8e1f64")?;
99 assert_eq!(f.number_part(), "8e1");
100 assert_eq!(f.integer_part(), "8");
101 assert_eq!(f.fractional_part(), None);
102 assert_eq!(f.exponent_part(), "e1");
103 assert_eq!(f.type_suffix(), Some(FloatType::F64));
104
105 let f = FloatLit::parse("8_7_6.1_23e15f32")?;
106 assert_eq!(f.number_part(), "8_7_6.1_23e15");
107 assert_eq!(f.integer_part(), "8_7_6");
108 assert_eq!(f.fractional_part(), Some("1_23"));
109 assert_eq!(f.exponent_part(), "e15");
110 assert_eq!(f.type_suffix(), Some(FloatType::F32));
111
112 let f = FloatLit::parse("8.2e-_04_9f64")?;
113 assert_eq!(f.number_part(), "8.2e-_04_9");
114 assert_eq!(f.integer_part(), "8");
115 assert_eq!(f.fractional_part(), Some("2"));
116 assert_eq!(f.exponent_part(), "e-_04_9");
117 assert_eq!(f.type_suffix(), Some(FloatType::F64));
118
119 Ok(())
120 }
121
122 #[test]
simple()123 fn simple() {
124 check!("3" ".14" "" -);
125 check!("3" ".14" "" f32);
126 check!("3" ".14" "" f64);
127
128 check!("3" "" "" f32);
129 check!("3" "" "e987654321" -);
130 check!("3" "" "e987654321" f64);
131
132 check!("42_888" ".05" "" -);
133 check!("42_888" ".05" "E5___" f32);
134 check!("123456789" "" "e_1" f64);
135 check!("123456789" ".99" "e_1" f64);
136 check!("123456789" ".99" "" f64);
137 check!("123456789" ".99" "" -);
138
139 check!("147" ".3_33" "" -);
140 check!("147" ".3_33__" "E3" f64);
141 check!("147" ".3_33__" "" f32);
142
143 check!("147" ".333" "e-10" -);
144 check!("147" ".333" "e-_7" f32);
145 check!("147" ".333" "e+10" -);
146 check!("147" ".333" "e+_7" f32);
147
148 check!("86" "." "" -);
149 check!("0" "." "" -);
150 check!("0_" "." "" -);
151 check!("0" ".0000001" "" -);
152 check!("0" ".000_0001" "" -);
153
154 check!("0" ".0" "e+0" -);
155 check!("0" "" "E+0" -);
156 check!("34" "" "e+0" -);
157 check!("0" ".9182" "E+0" f32);
158 }
159
160 #[test]
parse_err()161 fn parse_err() {
162 assert_err!(FloatLit, "", Empty, None);
163 assert_err_single!(FloatLit::parse("."), DoesNotStartWithDigit, 0);
164 assert_err_single!(FloatLit::parse("+"), DoesNotStartWithDigit, 0);
165 assert_err_single!(FloatLit::parse("-"), DoesNotStartWithDigit, 0);
166 assert_err_single!(FloatLit::parse("e"), DoesNotStartWithDigit, 0);
167 assert_err_single!(FloatLit::parse("e8"), DoesNotStartWithDigit, 0);
168 assert_err!(FloatLit, "0e", NoExponentDigits, 1..2);
169 assert_err_single!(FloatLit::parse("f32"), DoesNotStartWithDigit, 0);
170 assert_err_single!(FloatLit::parse("foo"), DoesNotStartWithDigit, 0);
171
172 assert_err_single!(FloatLit::parse("inf"), DoesNotStartWithDigit, 0);
173 assert_err_single!(FloatLit::parse("nan"), DoesNotStartWithDigit, 0);
174 assert_err_single!(FloatLit::parse("NaN"), DoesNotStartWithDigit, 0);
175 assert_err_single!(FloatLit::parse("NAN"), DoesNotStartWithDigit, 0);
176
177 assert_err_single!(FloatLit::parse("_2.7"), DoesNotStartWithDigit, 0);
178 assert_err_single!(FloatLit::parse(".5"), DoesNotStartWithDigit, 0);
179 assert_err_single!(FloatLit::parse("0x44.5"), InvalidFloatTypeSuffix, 1..6);
180 assert_err!(FloatLit, "1e", NoExponentDigits, 1..2);
181 assert_err!(FloatLit, "1.e4", UnexpectedChar, 2);
182 assert_err!(FloatLit, "3._4", UnexpectedChar, 2);
183 assert_err!(FloatLit, "12345._987", UnexpectedChar, 6);
184 assert_err!(FloatLit, "46._", UnexpectedChar, 3);
185 assert_err!(FloatLit, "46.f32", UnexpectedChar, 3);
186 assert_err!(FloatLit, "46.e3", UnexpectedChar, 3);
187 assert_err!(FloatLit, "46._e3", UnexpectedChar, 3);
188 assert_err!(FloatLit, "46.e3f64", UnexpectedChar, 3);
189 assert_err!(FloatLit, "23.4e_", NoExponentDigits, 4..6);
190 assert_err!(FloatLit, "23E___f32", NoExponentDigits, 2..6);
191 assert_err!(FloatLit, "7f23", InvalidFloatTypeSuffix, 1..4);
192 assert_err!(FloatLit, "7f320", InvalidFloatTypeSuffix, 1..5);
193 assert_err!(FloatLit, "7f64_", InvalidFloatTypeSuffix, 1..5);
194 assert_err!(FloatLit, "8f649", InvalidFloatTypeSuffix, 1..5);
195 assert_err!(FloatLit, "8f64f32", InvalidFloatTypeSuffix, 1..7);
196 assert_err!(FloatLit, "55e3.1", InvalidFloatTypeSuffix, 4..6); // suboptimal
197
198 assert_err!(FloatLit, "3.7+", InvalidFloatTypeSuffix, 3..4);
199 assert_err!(FloatLit, "3.7+2", InvalidFloatTypeSuffix, 3..5);
200 assert_err!(FloatLit, "3.7-", InvalidFloatTypeSuffix, 3..4);
201 assert_err!(FloatLit, "3.7-2", InvalidFloatTypeSuffix, 3..5);
202 assert_err!(FloatLit, "3.7e+", NoExponentDigits, 3..5);
203 assert_err!(FloatLit, "3.7e-", NoExponentDigits, 3..5);
204 assert_err!(FloatLit, "3.7e-+3", NoExponentDigits, 3..5); // suboptimal
205 assert_err!(FloatLit, "3.7e+-3", NoExponentDigits, 3..5); // suboptimal
206 }
207