1 | #include <fenv.h> |
2 | #include <math.h> |
3 | #include <float.h> |
4 | #include <stdlib.h> |
5 | #include <stdio.h> |
6 | #include <math-tests.h> |
7 | |
8 | #if !defined(FE_OVERFLOW) && !defined(FE_UNDERFLOW) |
9 | /* If there's no support for the exceptions this test is checking, |
10 | then just return success and allow the test to be compiled. */ |
11 | # define fetestexcept(e) 1 |
12 | #endif |
13 | |
14 | float zero = 0.0; |
15 | float inf = INFINITY; |
16 | |
17 | int |
18 | main (void) |
19 | { |
20 | int result = 0; |
21 | |
22 | float i = INFINITY; |
23 | float m = FLT_MAX; |
24 | feclearexcept (FE_ALL_EXCEPT); |
25 | if (nextafterf (x: m, y: i) != i) |
26 | { |
27 | puts (s: "nextafterf+ failed" ); |
28 | ++result; |
29 | } |
30 | if (EXCEPTION_TESTS (float) && fetestexcept (FE_OVERFLOW) == 0) |
31 | { |
32 | puts (s: "nextafterf+ did not overflow" ); |
33 | ++result; |
34 | } |
35 | feclearexcept (FE_ALL_EXCEPT); |
36 | if (nextafterf (x: -m, y: -i) != -i) |
37 | { |
38 | puts (s: "nextafterf- failed" ); |
39 | ++result; |
40 | } |
41 | if (EXCEPTION_TESTS (float) && fetestexcept (FE_OVERFLOW) == 0) |
42 | { |
43 | puts (s: "nextafterf- did not overflow" ); |
44 | ++result; |
45 | } |
46 | |
47 | i = 0; |
48 | m = FLT_MIN; |
49 | feclearexcept (FE_ALL_EXCEPT); |
50 | i = nextafterf (x: m, y: i); |
51 | if (i < 0 || i >= FLT_MIN) |
52 | { |
53 | puts (s: "nextafterf+ failed" ); |
54 | ++result; |
55 | } |
56 | if (EXCEPTION_TESTS (float) && fetestexcept (FE_UNDERFLOW) == 0) |
57 | { |
58 | puts (s: "nextafterf+ did not underflow" ); |
59 | ++result; |
60 | } |
61 | i = 0; |
62 | feclearexcept (FE_ALL_EXCEPT); |
63 | i = nextafterf (x: -m, y: -i); |
64 | if (i > 0 || i <= -FLT_MIN) |
65 | { |
66 | puts (s: "nextafterf- failed" ); |
67 | ++result; |
68 | } |
69 | if (EXCEPTION_TESTS (float) && fetestexcept (FE_UNDERFLOW) == 0) |
70 | { |
71 | puts (s: "nextafterf- did not underflow" ); |
72 | ++result; |
73 | } |
74 | i = -INFINITY; |
75 | feclearexcept (FE_ALL_EXCEPT); |
76 | m = nextafterf (x: zero, y: inf); |
77 | if (m < 0.0 || m >= FLT_MIN) |
78 | { |
79 | puts (s: "nextafterf+ failed" ); |
80 | ++result; |
81 | } |
82 | if (EXCEPTION_TESTS (float) && fetestexcept (FE_UNDERFLOW) == 0) |
83 | { |
84 | puts (s: "nextafterf+ did not underflow" ); |
85 | ++result; |
86 | } |
87 | feclearexcept (FE_ALL_EXCEPT); |
88 | if (nextafterf (x: m, y: i) != 0.0) |
89 | { |
90 | puts (s: "nextafterf+ failed" ); |
91 | ++result; |
92 | } |
93 | if (EXCEPTION_TESTS (float) && fetestexcept (FE_UNDERFLOW) == 0) |
94 | { |
95 | puts (s: "nextafterf+ did not underflow" ); |
96 | ++result; |
97 | } |
98 | feclearexcept (FE_ALL_EXCEPT); |
99 | m = nextafterf (x: copysignf (zero, -1.0), y: -inf); |
100 | if (m > 0.0 || m <= -FLT_MIN) |
101 | { |
102 | puts (s: "nextafterf- failed" ); |
103 | ++result; |
104 | } |
105 | if (EXCEPTION_TESTS (float) && fetestexcept (FE_UNDERFLOW) == 0) |
106 | { |
107 | puts (s: "nextafterf- did not underflow" ); |
108 | ++result; |
109 | } |
110 | feclearexcept (FE_ALL_EXCEPT); |
111 | if (nextafterf (x: m, y: -i) != 0.0) |
112 | { |
113 | puts (s: "nextafterf- failed" ); |
114 | ++result; |
115 | } |
116 | if (EXCEPTION_TESTS (float) && fetestexcept (FE_UNDERFLOW) == 0) |
117 | { |
118 | puts (s: "nextafterf- did not underflow" ); |
119 | ++result; |
120 | } |
121 | |
122 | double di = INFINITY; |
123 | double dm = DBL_MAX; |
124 | feclearexcept (FE_ALL_EXCEPT); |
125 | if (nextafter (x: dm, y: di) != di) |
126 | { |
127 | puts (s: "nextafter+ failed" ); |
128 | ++result; |
129 | } |
130 | if (EXCEPTION_TESTS (double) && fetestexcept (FE_OVERFLOW) == 0) |
131 | { |
132 | puts (s: "nextafter+ did not overflow" ); |
133 | ++result; |
134 | } |
135 | feclearexcept (FE_ALL_EXCEPT); |
136 | if (nextafter (x: -dm, y: -di) != -di) |
137 | { |
138 | puts (s: "nextafter failed" ); |
139 | ++result; |
140 | } |
141 | if (EXCEPTION_TESTS (double) && fetestexcept (FE_OVERFLOW) == 0) |
142 | { |
143 | puts (s: "nextafter- did not overflow" ); |
144 | ++result; |
145 | } |
146 | |
147 | di = 0; |
148 | dm = DBL_MIN; |
149 | feclearexcept (FE_ALL_EXCEPT); |
150 | di = nextafter (x: dm, y: di); |
151 | if (di < 0 || di >= DBL_MIN) |
152 | { |
153 | puts (s: "nextafter+ failed" ); |
154 | ++result; |
155 | } |
156 | if (EXCEPTION_TESTS (double) && fetestexcept (FE_UNDERFLOW) == 0) |
157 | { |
158 | puts (s: "nextafter+ did not underflow" ); |
159 | ++result; |
160 | } |
161 | di = 0; |
162 | feclearexcept (FE_ALL_EXCEPT); |
163 | di = nextafter (x: -dm, y: -di); |
164 | if (di > 0 || di <= -DBL_MIN) |
165 | { |
166 | puts (s: "nextafter- failed" ); |
167 | ++result; |
168 | } |
169 | if (EXCEPTION_TESTS (double) && fetestexcept (FE_UNDERFLOW) == 0) |
170 | { |
171 | puts (s: "nextafter- did not underflow" ); |
172 | ++result; |
173 | } |
174 | di = -INFINITY; |
175 | feclearexcept (FE_ALL_EXCEPT); |
176 | dm = nextafter (x: zero, y: inf); |
177 | if (dm < 0.0 || dm >= DBL_MIN) |
178 | { |
179 | puts (s: "nextafter+ failed" ); |
180 | ++result; |
181 | } |
182 | if (EXCEPTION_TESTS (double) && fetestexcept (FE_UNDERFLOW) == 0) |
183 | { |
184 | puts (s: "nextafter+ did not underflow" ); |
185 | ++result; |
186 | } |
187 | feclearexcept (FE_ALL_EXCEPT); |
188 | if (nextafter (x: dm, y: di) != 0.0) |
189 | { |
190 | puts (s: "nextafter+ failed" ); |
191 | ++result; |
192 | } |
193 | if (EXCEPTION_TESTS (double) && fetestexcept (FE_UNDERFLOW) == 0) |
194 | { |
195 | puts (s: "nextafter+ did not underflow" ); |
196 | ++result; |
197 | } |
198 | feclearexcept (FE_ALL_EXCEPT); |
199 | dm = nextafter (x: copysign (zero, -1.0), y: -inf); |
200 | if (dm > 0.0 || dm <= -DBL_MIN) |
201 | { |
202 | puts (s: "nextafter- failed" ); |
203 | ++result; |
204 | } |
205 | if (EXCEPTION_TESTS (double) && fetestexcept (FE_UNDERFLOW) == 0) |
206 | { |
207 | puts (s: "nextafter- did not underflow" ); |
208 | ++result; |
209 | } |
210 | feclearexcept (FE_ALL_EXCEPT); |
211 | if (nextafter (x: dm, y: -di) != 0.0) |
212 | { |
213 | puts (s: "nextafter- failed" ); |
214 | ++result; |
215 | } |
216 | if (EXCEPTION_TESTS (double) && fetestexcept (FE_UNDERFLOW) == 0) |
217 | { |
218 | puts (s: "nextafter- did not underflow" ); |
219 | ++result; |
220 | } |
221 | |
222 | long double li = INFINITY; |
223 | long double lm = LDBL_MAX; |
224 | feclearexcept (FE_ALL_EXCEPT); |
225 | if (nextafterl (x: lm, y: li) != li) |
226 | { |
227 | puts (s: "nextafterl+ failed" ); |
228 | ++result; |
229 | } |
230 | if (EXCEPTION_TESTS (long double) && fetestexcept (FE_OVERFLOW) == 0) |
231 | { |
232 | puts (s: "nextafterl+ did not overflow" ); |
233 | ++result; |
234 | } |
235 | feclearexcept (FE_ALL_EXCEPT); |
236 | if (nextafterl (x: -lm, y: -li) != -li) |
237 | { |
238 | puts (s: "nextafterl failed" ); |
239 | ++result; |
240 | } |
241 | if (EXCEPTION_TESTS (long double) && fetestexcept (FE_OVERFLOW) == 0) |
242 | { |
243 | puts (s: "nextafterl- did not overflow" ); |
244 | ++result; |
245 | } |
246 | |
247 | li = 0; |
248 | lm = LDBL_MIN; |
249 | feclearexcept (FE_ALL_EXCEPT); |
250 | li = nextafterl (x: lm, y: li); |
251 | if (li < 0 || li >= LDBL_MIN) |
252 | { |
253 | puts (s: "nextafterl+ failed" ); |
254 | ++result; |
255 | } |
256 | if (EXCEPTION_TESTS (long double) && fetestexcept (FE_UNDERFLOW) == 0) |
257 | { |
258 | puts (s: "nextafterl+ did not underflow" ); |
259 | ++result; |
260 | } |
261 | li = 0; |
262 | feclearexcept (FE_ALL_EXCEPT); |
263 | li = nextafterl (x: -lm, y: -li); |
264 | if (li > 0 || li <= -LDBL_MIN) |
265 | { |
266 | puts (s: "nextafterl- failed" ); |
267 | ++result; |
268 | } |
269 | if (EXCEPTION_TESTS (long double) && fetestexcept (FE_UNDERFLOW) == 0) |
270 | { |
271 | puts (s: "nextafterl- did not underflow" ); |
272 | ++result; |
273 | } |
274 | li = -INFINITY; |
275 | feclearexcept (FE_ALL_EXCEPT); |
276 | lm = nextafterl (x: zero, y: inf); |
277 | if (lm < 0.0 || lm >= LDBL_MIN) |
278 | { |
279 | puts (s: "nextafterl+ failed" ); |
280 | ++result; |
281 | } |
282 | if (EXCEPTION_TESTS (long double) && fetestexcept (FE_UNDERFLOW) == 0) |
283 | { |
284 | puts (s: "nextafterl+ did not underflow" ); |
285 | ++result; |
286 | } |
287 | feclearexcept (FE_ALL_EXCEPT); |
288 | if (nextafterl (x: lm, y: li) != 0.0) |
289 | { |
290 | puts (s: "nextafterl+ failed" ); |
291 | ++result; |
292 | } |
293 | if (EXCEPTION_TESTS (long double) && fetestexcept (FE_UNDERFLOW) == 0) |
294 | { |
295 | puts (s: "nextafterl+ did not underflow" ); |
296 | ++result; |
297 | } |
298 | feclearexcept (FE_ALL_EXCEPT); |
299 | lm = nextafterl (x: copysign (zero, -1.0), y: -inf); |
300 | if (lm > 0.0 || lm <= -LDBL_MIN) |
301 | { |
302 | puts (s: "nextafterl- failed" ); |
303 | ++result; |
304 | } |
305 | if (EXCEPTION_TESTS (long double) && fetestexcept (FE_UNDERFLOW) == 0) |
306 | { |
307 | puts (s: "nextafterl- did not underflow" ); |
308 | ++result; |
309 | } |
310 | feclearexcept (FE_ALL_EXCEPT); |
311 | if (nextafterl (x: lm, y: -li) != 0.0) |
312 | { |
313 | puts (s: "nextafterl- failed" ); |
314 | ++result; |
315 | } |
316 | if (EXCEPTION_TESTS (long double) && fetestexcept (FE_UNDERFLOW) == 0) |
317 | { |
318 | puts (s: "nextafterl- did not underflow" ); |
319 | ++result; |
320 | } |
321 | |
322 | return result; |
323 | } |
324 | |