1 /* ==========================================
2 Unity Project - A Test Framework for C
3 Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
4 [Released under MIT License. Please refer to license.txt for details]
5 ========================================== */
6
7 #include "unity.h"
8 #define TEST_INSTANCES
9 #include "self_assessment_utils.h"
10
11 static int SetToOneToFailInTearDown;
12 static int SetToOneMeanWeAlreadyCheckedThisGuy;
13
setUp(void)14 void setUp(void)
15 {
16 SetToOneToFailInTearDown = 0;
17 SetToOneMeanWeAlreadyCheckedThisGuy = 0;
18 }
19
tearDown(void)20 void tearDown(void)
21 {
22 endPutcharSpy(); /* Stop suppressing test output */
23 if (SetToOneToFailInTearDown == 1)
24 {
25 /* These will be skipped internally if already failed/ignored */
26 TEST_FAIL_MESSAGE("<= Failed in tearDown");
27 TEST_IGNORE_MESSAGE("<= Ignored in tearDown");
28 }
29 if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
30 {
31 UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]");
32 UNITY_OUTPUT_CHAR('\n');
33 }
34 }
35
testFloatsWithinDelta(void)36 void testFloatsWithinDelta(void)
37 {
38 #ifdef UNITY_EXCLUDE_FLOAT
39 TEST_IGNORE();
40 #else
41 TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
42 TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
43 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
44 TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
45
46 EXPECT_ABORT_BEGIN
47 TEST_ASSERT_FLOAT_NOT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
48 VERIFY_FAILS_END
49 #endif
50 }
51
testFloatsNotWithinDelta(void)52 void testFloatsNotWithinDelta(void)
53 {
54 #ifdef UNITY_EXCLUDE_FLOAT
55 TEST_IGNORE();
56 #else
57 TEST_ASSERT_FLOAT_NOT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
58
59 EXPECT_ABORT_BEGIN
60 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
61 VERIFY_FAILS_END
62 #endif
63 }
64
testFloatsEqual(void)65 void testFloatsEqual(void)
66 {
67 #ifdef UNITY_EXCLUDE_FLOAT
68 TEST_IGNORE();
69 #else
70 TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f);
71 TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f);
72 TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f);
73 TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f);
74
75 EXPECT_ABORT_BEGIN
76 TEST_ASSERT_NOT_EQUAL_FLOAT(-726.93724f, -726.9374f);
77 VERIFY_FAILS_END
78 #endif
79 }
80
testFloatsNotEqual(void)81 void testFloatsNotEqual(void)
82 {
83 #ifdef UNITY_EXCLUDE_FLOAT
84 TEST_IGNORE();
85 #else
86 TEST_ASSERT_NOT_EQUAL_FLOAT(9273.9649f, 9273.0049f);
87
88 EXPECT_ABORT_BEGIN
89 TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f);
90 VERIFY_FAILS_END
91 #endif
92 }
93
testFloatsNotEqualNegative1(void)94 void testFloatsNotEqualNegative1(void)
95 {
96 #ifdef UNITY_EXCLUDE_FLOAT
97 TEST_IGNORE();
98 #else
99 TEST_ASSERT_NOT_EQUAL_FLOAT(-9273.9649f, -9273.0049f);
100
101 EXPECT_ABORT_BEGIN
102 TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f);
103 VERIFY_FAILS_END
104 #endif
105 }
106
testFloatsNotEqualNegative2(void)107 void testFloatsNotEqualNegative2(void)
108 {
109 #ifdef UNITY_EXCLUDE_FLOAT
110 TEST_IGNORE();
111 #else
112 TEST_ASSERT_NOT_EQUAL_FLOAT(-9273.0049f, -9273.9649f);
113
114 EXPECT_ABORT_BEGIN
115 TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f);
116 VERIFY_FAILS_END
117 #endif
118 }
119
testFloatsNotEqualActualNaN(void)120 void testFloatsNotEqualActualNaN(void)
121 {
122 #ifdef UNITY_EXCLUDE_FLOAT
123 TEST_IGNORE();
124 #else
125 TEST_ASSERT_NOT_EQUAL_FLOAT(85.963f, 0.0f / f_zero);
126
127 EXPECT_ABORT_BEGIN
128 TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero);
129 VERIFY_FAILS_END
130 #endif
131 }
132
testFloatsNotEqualExpectedNaN(void)133 void testFloatsNotEqualExpectedNaN(void)
134 {
135 #ifdef UNITY_EXCLUDE_FLOAT
136 TEST_IGNORE();
137 #else
138 TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 85.963f);
139
140 EXPECT_ABORT_BEGIN
141 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f);
142 VERIFY_FAILS_END
143 #endif
144 }
145
testFloatsEqualBothNaN(void)146 void testFloatsEqualBothNaN(void)
147 {
148 #ifdef UNITY_EXCLUDE_FLOAT
149 TEST_IGNORE();
150 #else
151 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero);
152
153 EXPECT_ABORT_BEGIN
154 TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero);
155 VERIFY_FAILS_END
156 #endif
157 }
158
testFloatsNotEqualInfNaN(void)159 void testFloatsNotEqualInfNaN(void)
160 {
161 #ifdef UNITY_EXCLUDE_FLOAT
162 TEST_IGNORE();
163 #else
164 TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero);
165
166 EXPECT_ABORT_BEGIN
167 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero);
168 VERIFY_FAILS_END
169 #endif
170 }
171
testFloatsNotEqualNaNInf(void)172 void testFloatsNotEqualNaNInf(void)
173 {
174 #ifdef UNITY_EXCLUDE_FLOAT
175 TEST_IGNORE();
176 #else
177 TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero);
178
179 EXPECT_ABORT_BEGIN
180 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero);
181 VERIFY_FAILS_END
182 #endif
183 }
184
testFloatsNotEqualActualInf(void)185 void testFloatsNotEqualActualInf(void)
186 {
187 #ifdef UNITY_EXCLUDE_FLOAT
188 TEST_IGNORE();
189 #else
190 TEST_ASSERT_NOT_EQUAL_FLOAT(321.642f, 1.0f / f_zero);
191
192 EXPECT_ABORT_BEGIN
193 TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero);
194 VERIFY_FAILS_END
195 #endif
196 }
197
testFloatsNotEqualExpectedInf(void)198 void testFloatsNotEqualExpectedInf(void)
199 {
200 #ifdef UNITY_EXCLUDE_FLOAT
201 TEST_IGNORE();
202 #else
203 TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 321.642f);
204
205 EXPECT_ABORT_BEGIN
206 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f);
207 VERIFY_FAILS_END
208 #endif
209 }
210
testFloatsEqualBothInf(void)211 void testFloatsEqualBothInf(void)
212 {
213 #ifdef UNITY_EXCLUDE_FLOAT
214 TEST_IGNORE();
215 #else
216 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero);
217
218 EXPECT_ABORT_BEGIN
219 TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero);
220 VERIFY_FAILS_END
221 #endif
222 }
223
testFloatsNotEqualPlusMinusInf(void)224 void testFloatsNotEqualPlusMinusInf(void)
225 {
226 #ifdef UNITY_EXCLUDE_FLOAT
227 TEST_IGNORE();
228 #else
229 TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero);
230
231 EXPECT_ABORT_BEGIN
232 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero);
233 VERIFY_FAILS_END
234 #endif
235 }
236
testFloatsGreaterThan(void)237 void testFloatsGreaterThan(void)
238 {
239 #ifdef UNITY_EXCLUDE_FLOAT
240 TEST_IGNORE();
241 #else
242 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 2.0f);
243 TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f, 1.0f);
244 TEST_ASSERT_GREATER_THAN_FLOAT(-2.0f, -1.0f);
245 #endif
246 }
247
testFloatsGreaterThanInf(void)248 void testFloatsGreaterThanInf(void)
249 {
250 #ifdef UNITY_EXCLUDE_FLOAT
251 TEST_IGNORE();
252 #else
253 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 1.0f / f_zero);
254 TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, 1.0f / f_zero);
255 TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, 1.0f);
256 #endif
257 }
258
testFloatsNotGreaterThan(void)259 void testFloatsNotGreaterThan(void)
260 {
261 #ifdef UNITY_EXCLUDE_FLOAT
262 TEST_IGNORE();
263 #else
264 EXPECT_ABORT_BEGIN
265 TEST_ASSERT_GREATER_THAN_FLOAT(2.0f, 1.0f);
266 VERIFY_FAILS_END
267 #endif
268 }
269
testFloatsNotGreaterThanNanActual(void)270 void testFloatsNotGreaterThanNanActual(void)
271 {
272 #ifdef UNITY_EXCLUDE_FLOAT
273 TEST_IGNORE();
274 #else
275 EXPECT_ABORT_BEGIN
276 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 0.0f / f_zero);
277 VERIFY_FAILS_END
278 #endif
279 }
280
testFloatsNotGreaterThanNanThreshold(void)281 void testFloatsNotGreaterThanNanThreshold(void)
282 {
283 #ifdef UNITY_EXCLUDE_FLOAT
284 TEST_IGNORE();
285 #else
286 EXPECT_ABORT_BEGIN
287 TEST_ASSERT_GREATER_THAN_FLOAT(0.0f / f_zero, 1.0f);
288 VERIFY_FAILS_END
289 #endif
290 }
291
testFloatsNotGreaterThanNanBoth(void)292 void testFloatsNotGreaterThanNanBoth(void)
293 {
294 #ifdef UNITY_EXCLUDE_FLOAT
295 TEST_IGNORE();
296 #else
297 EXPECT_ABORT_BEGIN
298 TEST_ASSERT_GREATER_THAN_FLOAT(0.0f / f_zero, 0.0f / f_zero);
299 VERIFY_FAILS_END
300 #endif
301 }
302
testFloatsNotGreaterThanInfActual(void)303 void testFloatsNotGreaterThanInfActual(void)
304 {
305 #ifdef UNITY_EXCLUDE_FLOAT
306 TEST_IGNORE();
307 #else
308 EXPECT_ABORT_BEGIN
309 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f / f_zero, 1.0f);
310 VERIFY_FAILS_END
311 #endif
312 }
313
testFloatsNotGreaterThanNegInf(void)314 void testFloatsNotGreaterThanNegInf(void)
315 {
316 #ifdef UNITY_EXCLUDE_FLOAT
317 TEST_IGNORE();
318 #else
319 EXPECT_ABORT_BEGIN
320 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, -1.0f / f_zero);
321 VERIFY_FAILS_END
322 #endif
323 }
324
testFloatsNotGreaterThanBothInf(void)325 void testFloatsNotGreaterThanBothInf(void)
326 {
327 #ifdef UNITY_EXCLUDE_FLOAT
328 TEST_IGNORE();
329 #else
330 EXPECT_ABORT_BEGIN
331 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f / f_zero, 1.0f / f_zero);
332 VERIFY_FAILS_END
333 #endif
334 }
335
testFloatsNotGreaterThanBothNegInf(void)336 void testFloatsNotGreaterThanBothNegInf(void)
337 {
338 #ifdef UNITY_EXCLUDE_FLOAT
339 TEST_IGNORE();
340 #else
341 EXPECT_ABORT_BEGIN
342 TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, -1.0f / f_zero);
343 VERIFY_FAILS_END
344 #endif
345 }
346
testFloatsGreaterOrEqual(void)347 void testFloatsGreaterOrEqual(void)
348 {
349 #ifdef UNITY_EXCLUDE_FLOAT
350 TEST_IGNORE();
351 #else
352 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 2.0f);
353 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(2.0f, 2.0f);
354 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f, 1.0f);
355 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-2.0f, -1.0f);
356 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-2.0f, -2.0f);
357 #endif
358 }
359
testFloatsGreaterOrEqualInf(void)360 void testFloatsGreaterOrEqualInf(void)
361 {
362 #ifdef UNITY_EXCLUDE_FLOAT
363 TEST_IGNORE();
364 #else
365 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 1.0f / f_zero);
366 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f / f_zero);
367 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f);
368 #endif
369 }
370
testFloatsNotGreaterOrEqual(void)371 void testFloatsNotGreaterOrEqual(void)
372 {
373 #ifdef UNITY_EXCLUDE_FLOAT
374 TEST_IGNORE();
375 #else
376 EXPECT_ABORT_BEGIN
377 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(2.0f, 1.0f);
378 VERIFY_FAILS_END
379 #endif
380 }
381
testFloatsNotGreaterOrEqualNanActual(void)382 void testFloatsNotGreaterOrEqualNanActual(void)
383 {
384 #ifdef UNITY_EXCLUDE_FLOAT
385 TEST_IGNORE();
386 #else
387 EXPECT_ABORT_BEGIN
388 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 0.0f / f_zero);
389 VERIFY_FAILS_END
390 #endif
391 }
392
testFloatsNotGreaterOrEqualNanThreshold(void)393 void testFloatsNotGreaterOrEqualNanThreshold(void)
394 {
395 #ifdef UNITY_EXCLUDE_FLOAT
396 TEST_IGNORE();
397 #else
398 EXPECT_ABORT_BEGIN
399 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(0.0f / f_zero, 1.0f);
400 VERIFY_FAILS_END
401 #endif
402 }
403
testFloatsGreaterOrEqualNanBoth(void)404 void testFloatsGreaterOrEqualNanBoth(void)
405 {
406 #ifdef UNITY_EXCLUDE_FLOAT
407 TEST_IGNORE();
408 #else
409 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero);
410 #endif
411 }
412
testFloatsNotGreaterOrEqualInfActual(void)413 void testFloatsNotGreaterOrEqualInfActual(void)
414 {
415 #ifdef UNITY_EXCLUDE_FLOAT
416 TEST_IGNORE();
417 #else
418 EXPECT_ABORT_BEGIN
419 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f);
420 VERIFY_FAILS_END
421 #endif
422 }
423
testFloatsNotGreaterOrEqualNegInf(void)424 void testFloatsNotGreaterOrEqualNegInf(void)
425 {
426 #ifdef UNITY_EXCLUDE_FLOAT
427 TEST_IGNORE();
428 #else
429 EXPECT_ABORT_BEGIN
430 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, -1.0f / f_zero);
431 VERIFY_FAILS_END
432 #endif
433 }
434
testFloatsGreaterOrEqualBothInf(void)435 void testFloatsGreaterOrEqualBothInf(void)
436 {
437 #ifdef UNITY_EXCLUDE_FLOAT
438 TEST_IGNORE();
439 #else
440 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero);
441 #endif
442 }
443
testFloatsGreaterOrEqualBothNegInf(void)444 void testFloatsGreaterOrEqualBothNegInf(void)
445 {
446 #ifdef UNITY_EXCLUDE_FLOAT
447 TEST_IGNORE();
448 #else
449 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, -1.0f / f_zero);
450 #endif
451 }
452
testFloatsLessThan(void)453 void testFloatsLessThan(void)
454 {
455 #ifdef UNITY_EXCLUDE_FLOAT
456 TEST_IGNORE();
457 #else
458 TEST_ASSERT_LESS_THAN_FLOAT(2.0f, 1.0f);
459 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, -1.0f);
460 TEST_ASSERT_LESS_THAN_FLOAT(-1.0f, -2.0f);
461 #endif
462 }
463
testFloatsLessThanInf(void)464 void testFloatsLessThanInf(void)
465 {
466 #ifdef UNITY_EXCLUDE_FLOAT
467 TEST_IGNORE();
468 #else
469 TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, 1.0f);
470 TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, -1.0f / f_zero);
471 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, -1.0f / f_zero);
472 #endif
473 }
474
testFloatsNotLessThan(void)475 void testFloatsNotLessThan(void)
476 {
477 #ifdef UNITY_EXCLUDE_FLOAT
478 TEST_IGNORE();
479 #else
480 EXPECT_ABORT_BEGIN
481 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 2.0f);
482 VERIFY_FAILS_END
483 #endif
484 }
485
testFloatsNotLessThanNanActual(void)486 void testFloatsNotLessThanNanActual(void)
487 {
488 #ifdef UNITY_EXCLUDE_FLOAT
489 TEST_IGNORE();
490 #else
491 EXPECT_ABORT_BEGIN
492 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 0.0f / f_zero);
493 VERIFY_FAILS_END
494 #endif
495 }
496
testFloatsNotLessThanNanThreshold(void)497 void testFloatsNotLessThanNanThreshold(void)
498 {
499 #ifdef UNITY_EXCLUDE_FLOAT
500 TEST_IGNORE();
501 #else
502 EXPECT_ABORT_BEGIN
503 TEST_ASSERT_LESS_THAN_FLOAT(0.0f / f_zero, 1.0f);
504 VERIFY_FAILS_END
505 #endif
506 }
507
testFloatsNotLessThanNanBoth(void)508 void testFloatsNotLessThanNanBoth(void)
509 {
510 #ifdef UNITY_EXCLUDE_FLOAT
511 TEST_IGNORE();
512 #else
513 EXPECT_ABORT_BEGIN
514 TEST_ASSERT_LESS_THAN_FLOAT(0.0f / f_zero, 0.0f / f_zero);
515 VERIFY_FAILS_END
516 #endif
517 }
518
testFloatsNotLessThanInf(void)519 void testFloatsNotLessThanInf(void)
520 {
521 #ifdef UNITY_EXCLUDE_FLOAT
522 TEST_IGNORE();
523 #else
524 EXPECT_ABORT_BEGIN
525 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 1.0f / f_zero);
526 VERIFY_FAILS_END
527 #endif
528 }
529
testFloatsNotLessThanNegInf(void)530 void testFloatsNotLessThanNegInf(void)
531 {
532 #ifdef UNITY_EXCLUDE_FLOAT
533 TEST_IGNORE();
534 #else
535 EXPECT_ABORT_BEGIN
536 TEST_ASSERT_LESS_THAN_FLOAT(-1.0f / f_zero, 1.0f);
537 VERIFY_FAILS_END
538 #endif
539 }
540
testFloatsNotLessThanBothInf(void)541 void testFloatsNotLessThanBothInf(void)
542 {
543 #ifdef UNITY_EXCLUDE_FLOAT
544 TEST_IGNORE();
545 #else
546 EXPECT_ABORT_BEGIN
547 TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, 1.0f / f_zero);
548 VERIFY_FAILS_END
549 #endif
550 }
551
testFloatsNotLessThanBothNegInf(void)552 void testFloatsNotLessThanBothNegInf(void)
553 {
554 #ifdef UNITY_EXCLUDE_FLOAT
555 TEST_IGNORE();
556 #else
557 EXPECT_ABORT_BEGIN
558 TEST_ASSERT_LESS_THAN_FLOAT(-1.0f / f_zero, -1.0f / f_zero);
559 VERIFY_FAILS_END
560 #endif
561 }
testFloatsLessOrEqual(void)562 void testFloatsLessOrEqual(void)
563 {
564 #ifdef UNITY_EXCLUDE_FLOAT
565 TEST_IGNORE();
566 #else
567 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(2.0f, 1.0f);
568 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(2.0f, 2.0f);
569 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, -1.0f);
570 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f, -2.0f);
571 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-2.0f, -2.0f);
572 #endif
573 }
574
testFloatsLessOrEqualInf(void)575 void testFloatsLessOrEqualInf(void)
576 {
577 #ifdef UNITY_EXCLUDE_FLOAT
578 TEST_IGNORE();
579 #else
580 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f);
581 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero);
582 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, -1.0f / f_zero);
583 #endif
584 }
585
testFloatsNotLessOrEqual(void)586 void testFloatsNotLessOrEqual(void)
587 {
588 #ifdef UNITY_EXCLUDE_FLOAT
589 TEST_IGNORE();
590 #else
591 EXPECT_ABORT_BEGIN
592 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 2.0f);
593 VERIFY_FAILS_END
594 #endif
595 }
596
testFloatsNotLessOrEqualNanActual(void)597 void testFloatsNotLessOrEqualNanActual(void)
598 {
599 #ifdef UNITY_EXCLUDE_FLOAT
600 TEST_IGNORE();
601 #else
602 EXPECT_ABORT_BEGIN
603 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 0.0f / f_zero);
604 VERIFY_FAILS_END
605 #endif
606 }
607
testFloatsNotLessOrEqualNanThreshold(void)608 void testFloatsNotLessOrEqualNanThreshold(void)
609 {
610 #ifdef UNITY_EXCLUDE_FLOAT
611 TEST_IGNORE();
612 #else
613 EXPECT_ABORT_BEGIN
614 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(0.0f / f_zero, 1.0f);
615 VERIFY_FAILS_END
616 #endif
617 }
618
testFloatsLessOrEqualNanBoth(void)619 void testFloatsLessOrEqualNanBoth(void)
620 {
621 #ifdef UNITY_EXCLUDE_FLOAT
622 TEST_IGNORE();
623 #else
624 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero);
625 #endif
626 }
627
testFloatsNotLessOrEqualInf(void)628 void testFloatsNotLessOrEqualInf(void)
629 {
630 #ifdef UNITY_EXCLUDE_FLOAT
631 TEST_IGNORE();
632 #else
633 EXPECT_ABORT_BEGIN
634 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 1.0f / f_zero);
635 VERIFY_FAILS_END
636 #endif
637 }
638
testFloatsNotLessOrEqualNegInf(void)639 void testFloatsNotLessOrEqualNegInf(void)
640 {
641 #ifdef UNITY_EXCLUDE_FLOAT
642 TEST_IGNORE();
643 #else
644 EXPECT_ABORT_BEGIN
645 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f);
646 VERIFY_FAILS_END
647 #endif
648 }
649
testFloatsLessOrEqualBothInf(void)650 void testFloatsLessOrEqualBothInf(void)
651 {
652 #ifdef UNITY_EXCLUDE_FLOAT
653 TEST_IGNORE();
654 #else
655 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero);
656 #endif
657 }
658
testFloatsLessOrEqualBothNegInf(void)659 void testFloatsLessOrEqualBothNegInf(void)
660 {
661 #ifdef UNITY_EXCLUDE_FLOAT
662 TEST_IGNORE();
663 #else
664 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f / f_zero, -1.0f / f_zero);
665 #endif
666 }
667
testFloatIsPosInf1(void)668 void testFloatIsPosInf1(void)
669 {
670 #ifdef UNITY_EXCLUDE_FLOAT
671 TEST_IGNORE();
672 #else
673 TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero);
674 #endif
675 }
676
testFloatIsPosInf2(void)677 void testFloatIsPosInf2(void)
678 {
679 #ifdef UNITY_EXCLUDE_FLOAT
680 TEST_IGNORE();
681 #else
682 EXPECT_ABORT_BEGIN
683 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero);
684 VERIFY_FAILS_END
685 #endif
686 }
687
testFloatIsNegInf1(void)688 void testFloatIsNegInf1(void)
689 {
690 #ifdef UNITY_EXCLUDE_FLOAT
691 TEST_IGNORE();
692 #else
693 TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero);
694 #endif
695 }
696
testFloatIsNegInf2(void)697 void testFloatIsNegInf2(void)
698 {
699 #ifdef UNITY_EXCLUDE_FLOAT
700 TEST_IGNORE();
701 #else
702 EXPECT_ABORT_BEGIN
703 TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero);
704 VERIFY_FAILS_END
705 #endif
706 }
707
testFloatIsNotPosInf1(void)708 void testFloatIsNotPosInf1(void)
709 {
710 #ifdef UNITY_EXCLUDE_FLOAT
711 TEST_IGNORE();
712 #else
713 EXPECT_ABORT_BEGIN
714 TEST_ASSERT_FLOAT_IS_INF(2.0f);
715 VERIFY_FAILS_END
716 #endif
717 }
718
testFloatIsNotPosInf2(void)719 void testFloatIsNotPosInf2(void)
720 {
721 #ifdef UNITY_EXCLUDE_FLOAT
722 TEST_IGNORE();
723 #else
724 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f);
725 #endif
726 }
727
testFloatIsNotNegInf(void)728 void testFloatIsNotNegInf(void)
729 {
730 #ifdef UNITY_EXCLUDE_FLOAT
731 TEST_IGNORE();
732 #else
733 EXPECT_ABORT_BEGIN
734 TEST_ASSERT_FLOAT_IS_NEG_INF(-999.876f);
735 VERIFY_FAILS_END
736 #endif
737 }
738
testFloatIsNan1(void)739 void testFloatIsNan1(void)
740 {
741 #ifdef UNITY_EXCLUDE_FLOAT
742 TEST_IGNORE();
743 #else
744 TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero);
745 #endif
746 }
747
testFloatIsNan2(void)748 void testFloatIsNan2(void)
749 {
750 #ifdef UNITY_EXCLUDE_FLOAT
751 TEST_IGNORE();
752 #else
753 EXPECT_ABORT_BEGIN
754 TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero);
755 VERIFY_FAILS_END
756 #endif
757 }
758
testFloatIsNotNan1(void)759 void testFloatIsNotNan1(void)
760 {
761 #ifdef UNITY_EXCLUDE_FLOAT
762 TEST_IGNORE();
763 #else
764 EXPECT_ABORT_BEGIN
765 TEST_ASSERT_FLOAT_IS_NAN(234.9f);
766 VERIFY_FAILS_END
767 #endif
768 }
769
testFloatIsNotNan2(void)770 void testFloatIsNotNan2(void)
771 {
772 #ifdef UNITY_EXCLUDE_FLOAT
773 TEST_IGNORE();
774 #else
775 TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f);
776 #endif
777 }
778
testFloatInfIsNotNan(void)779 void testFloatInfIsNotNan(void)
780 {
781 #ifdef UNITY_EXCLUDE_FLOAT
782 TEST_IGNORE();
783 #else
784 EXPECT_ABORT_BEGIN
785 TEST_ASSERT_FLOAT_IS_NAN(1.0f / f_zero);
786 VERIFY_FAILS_END
787 #endif
788 }
789
testFloatNanIsNotInf(void)790 void testFloatNanIsNotInf(void)
791 {
792 #ifdef UNITY_EXCLUDE_FLOAT
793 TEST_IGNORE();
794 #else
795 EXPECT_ABORT_BEGIN
796 TEST_ASSERT_FLOAT_IS_INF(0.0f / f_zero);
797 VERIFY_FAILS_END
798 #endif
799 }
800
testFloatIsDeterminate1(void)801 void testFloatIsDeterminate1(void)
802 {
803 #ifdef UNITY_EXCLUDE_FLOAT
804 TEST_IGNORE();
805 #else
806 TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f);
807 TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f);
808 TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f);
809 #endif
810 }
811
testFloatIsDeterminate2(void)812 void testFloatIsDeterminate2(void)
813 {
814 #ifdef UNITY_EXCLUDE_FLOAT
815 TEST_IGNORE();
816 #else
817 EXPECT_ABORT_BEGIN
818 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f);
819 VERIFY_FAILS_END
820 #endif
821 }
822
testFloatIsNotDeterminate1(void)823 void testFloatIsNotDeterminate1(void)
824 {
825 #ifdef UNITY_EXCLUDE_FLOAT
826 TEST_IGNORE();
827 #else
828 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero);
829 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero);
830 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero);
831 #endif
832 }
833
testFloatIsNotDeterminate2(void)834 void testFloatIsNotDeterminate2(void)
835 {
836 #ifdef UNITY_EXCLUDE_FLOAT
837 TEST_IGNORE();
838 #else
839 EXPECT_ABORT_BEGIN
840 TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero);
841 VERIFY_FAILS_END
842 #endif
843 }
844
testFloatTraitFailsOnInvalidTrait(void)845 void testFloatTraitFailsOnInvalidTrait(void)
846 {
847 #ifdef UNITY_EXCLUDE_FLOAT
848 TEST_IGNORE();
849 #else
850 EXPECT_ABORT_BEGIN
851 UnityAssertFloatSpecial(1.0f, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT);
852 VERIFY_FAILS_END
853 #endif
854 }
855
testEqualFloatArrays(void)856 void testEqualFloatArrays(void)
857 {
858 #ifdef UNITY_EXCLUDE_FLOAT
859 TEST_IGNORE();
860 #else
861 float p0[] = {1.0f, -8.0f, 25.4f, -0.123f};
862 float p1[] = {1.0f, -8.0f, 25.4f, -0.123f};
863 float p2[] = {1.0f, -8.0f, 25.4f, -0.2f};
864 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f};
865
866 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1);
867 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4);
868 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
869 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3);
870 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1);
871 TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1);
872 #endif
873 }
874
testNotEqualFloatArraysExpectedNull(void)875 void testNotEqualFloatArraysExpectedNull(void)
876 {
877 #ifdef UNITY_EXCLUDE_FLOAT
878 TEST_IGNORE();
879 #else
880 float* p0 = NULL;
881 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f};
882
883 EXPECT_ABORT_BEGIN
884 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
885 VERIFY_FAILS_END
886 #endif
887 }
888
testNotEqualFloatArraysActualNull(void)889 void testNotEqualFloatArraysActualNull(void)
890 {
891 #ifdef UNITY_EXCLUDE_FLOAT
892 TEST_IGNORE();
893 #else
894 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
895 float* p1 = NULL;
896
897 EXPECT_ABORT_BEGIN
898 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
899 VERIFY_FAILS_END
900 #endif
901 }
902
testNotEqualFloatArrays1(void)903 void testNotEqualFloatArrays1(void)
904 {
905 #ifdef UNITY_EXCLUDE_FLOAT
906 TEST_IGNORE();
907 #else
908 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
909 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f};
910
911 EXPECT_ABORT_BEGIN
912 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
913 VERIFY_FAILS_END
914 #endif
915 }
916
testNotEqualFloatArrays2(void)917 void testNotEqualFloatArrays2(void)
918 {
919 #ifdef UNITY_EXCLUDE_FLOAT
920 TEST_IGNORE();
921 #else
922 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
923 float p1[] = {2.0f, 8.0f, 25.4f, 0.253f};
924
925 EXPECT_ABORT_BEGIN
926 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
927 VERIFY_FAILS_END
928 #endif
929 }
930
testNotEqualFloatArrays3(void)931 void testNotEqualFloatArrays3(void)
932 {
933 #ifdef UNITY_EXCLUDE_FLOAT
934 TEST_IGNORE();
935 #else
936 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f};
937 float p1[] = {1.0f, 8.0f, 25.5f, 0.253f};
938
939 EXPECT_ABORT_BEGIN
940 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
941 VERIFY_FAILS_END
942 #endif
943 }
944
testNotEqualFloatArraysNegative1(void)945 void testNotEqualFloatArraysNegative1(void)
946 {
947 #ifdef UNITY_EXCLUDE_FLOAT
948 TEST_IGNORE();
949 #else
950 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
951 float p1[] = {-1.0f, -8.0f, -25.4f, -0.252f};
952
953 EXPECT_ABORT_BEGIN
954 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
955 VERIFY_FAILS_END
956 #endif
957 }
958
testNotEqualFloatArraysNegative2(void)959 void testNotEqualFloatArraysNegative2(void)
960 {
961 #ifdef UNITY_EXCLUDE_FLOAT
962 TEST_IGNORE();
963 #else
964 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
965 float p1[] = {-2.0f, -8.0f, -25.4f, -0.253f};
966
967 EXPECT_ABORT_BEGIN
968 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
969 VERIFY_FAILS_END
970 #endif
971 }
972
testNotEqualFloatArraysNegative3(void)973 void testNotEqualFloatArraysNegative3(void)
974 {
975 #ifdef UNITY_EXCLUDE_FLOAT
976 TEST_IGNORE();
977 #else
978 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f};
979 float p1[] = {-1.0f, -8.0f, -25.5f, -0.253f};
980
981 EXPECT_ABORT_BEGIN
982 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
983 VERIFY_FAILS_END
984 #endif
985 }
986
testEqualFloatArraysNaN(void)987 void testEqualFloatArraysNaN(void)
988 {
989 #ifdef UNITY_EXCLUDE_FLOAT
990 TEST_IGNORE();
991 #else
992 float p0[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f};
993 float p1[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f};
994
995 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
996 #endif
997 }
998
testEqualFloatArraysInf(void)999 void testEqualFloatArraysInf(void)
1000 {
1001 #ifdef UNITY_EXCLUDE_FLOAT
1002 TEST_IGNORE();
1003 #else
1004 float p0[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f};
1005 float p1[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f};
1006
1007 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
1008 #endif
1009 }
1010
testNotEqualFloatArraysLengthZero(void)1011 void testNotEqualFloatArraysLengthZero(void)
1012 {
1013 #ifdef UNITY_EXCLUDE_FLOAT
1014 TEST_IGNORE();
1015 #else
1016 float p0[1] = {0.0f};
1017 float p1[1] = {0.0f};
1018
1019 EXPECT_ABORT_BEGIN
1020 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0);
1021 VERIFY_FAILS_END
1022 #endif
1023 }
1024
testFloatArraysWithin(void)1025 void testFloatArraysWithin(void)
1026 {
1027 #ifdef UNITY_EXCLUDE_FLOAT
1028 TEST_IGNORE();
1029 #else
1030 float p0[] = {1.0f, -8.0f, 25.4f, -0.123f};
1031 float p1[] = {1.0f, -8.0f, 25.4f, -0.123f};
1032 float p2[] = {1.0f, -8.0f, 25.4f, -0.2f};
1033 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f};
1034 float p4[] = {2.0f, -9.0f, 26.2f, 0.26f};
1035 float p5[] = {-1.0f, -7.0f, 29.0f, 2.6f};
1036
1037 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p0, 1);
1038 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p0, 4);
1039 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p1, 4);
1040 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p2, 3);
1041 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p3, 1);
1042 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p4, 1);
1043 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p4, 4);
1044 TEST_ASSERT_FLOAT_ARRAY_WITHIN(2.0f, p0, p5, 1);
1045 TEST_ASSERT_FLOAT_ARRAY_WITHIN(2.0f, p0, p5, 2);
1046 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, NULL, NULL, 1);
1047 #endif
1048 }
1049
testFloatArraysWithinUnusualDelta(void)1050 void testFloatArraysWithinUnusualDelta(void)
1051 {
1052 #ifdef UNITY_EXCLUDE_FLOAT
1053 TEST_IGNORE();
1054 #else
1055 float p0[] = {(float)-INFINITY, -8.0f, 25.4f, -0.123f};
1056 float p1[] = {(float)INFINITY, 10.1f};
1057
1058 TEST_ASSERT_FLOAT_ARRAY_WITHIN(INFINITY, p0, p1, 2);
1059
1060 EXPECT_ABORT_BEGIN
1061 TEST_ASSERT_FLOAT_ARRAY_WITHIN(NAN, p0, p0, 4);
1062 VERIFY_FAILS_END
1063 #endif
1064 }
1065
testEqualFloatEachEqual(void)1066 void testEqualFloatEachEqual(void)
1067 {
1068 #ifdef UNITY_EXCLUDE_FLOAT
1069 TEST_IGNORE();
1070 #else
1071 float p0[] = {1.0f, 1.0f, 1.0f, 1.0f};
1072 float p1[] = {-0.123f, -0.123f, -0.123f, -0.123f};
1073 float p2[] = {25.4f, 25.4f, 25.4f, -0.2f};
1074 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f};
1075
1076 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 1);
1077 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4);
1078 TEST_ASSERT_EACH_EQUAL_FLOAT(-0.123f, p1, 4);
1079 TEST_ASSERT_EACH_EQUAL_FLOAT(25.4f, p2, 3);
1080 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p3, 1);
1081 #endif
1082 }
1083
testNotEqualFloatEachEqualActualNull(void)1084 void testNotEqualFloatEachEqualActualNull(void)
1085 {
1086 #ifdef UNITY_EXCLUDE_FLOAT
1087 TEST_IGNORE();
1088 #else
1089 float* p0 = NULL;
1090
1091 EXPECT_ABORT_BEGIN
1092 TEST_ASSERT_EACH_EQUAL_FLOAT(5, p0, 4);
1093 VERIFY_FAILS_END
1094 #endif
1095 }
1096
testNotEqualFloatEachEqual1(void)1097 void testNotEqualFloatEachEqual1(void)
1098 {
1099 #ifdef UNITY_EXCLUDE_FLOAT
1100 TEST_IGNORE();
1101 #else
1102 float p0[] = {0.253f, 8.0f, 0.253f, 0.253f};
1103
1104 EXPECT_ABORT_BEGIN
1105 TEST_ASSERT_EACH_EQUAL_FLOAT(0.253f, p0, 4);
1106 VERIFY_FAILS_END
1107 #endif
1108 }
1109
testNotEqualFloatEachEqual2(void)1110 void testNotEqualFloatEachEqual2(void)
1111 {
1112 #ifdef UNITY_EXCLUDE_FLOAT
1113 TEST_IGNORE();
1114 #else
1115 float p0[] = {8.0f, 8.0f, 8.0f, 0.253f};
1116
1117 EXPECT_ABORT_BEGIN
1118 TEST_ASSERT_EACH_EQUAL_FLOAT(8.0f, p0, 4);
1119 VERIFY_FAILS_END
1120 #endif
1121 }
1122
testNotEqualFloatEachEqual3(void)1123 void testNotEqualFloatEachEqual3(void)
1124 {
1125 #ifdef UNITY_EXCLUDE_FLOAT
1126 TEST_IGNORE();
1127 #else
1128 float p0[] = {1.0f, 1.0f, 1.0f, 0.253f};
1129
1130 EXPECT_ABORT_BEGIN
1131 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4);
1132 VERIFY_FAILS_END
1133 #endif
1134 }
1135
testNotEqualFloatEachEqualNegative1(void)1136 void testNotEqualFloatEachEqualNegative1(void)
1137 {
1138 #ifdef UNITY_EXCLUDE_FLOAT
1139 TEST_IGNORE();
1140 #else
1141 float p0[] = {-1.0f, -0.253f, -0.253f, -0.253f};
1142
1143 EXPECT_ABORT_BEGIN
1144 TEST_ASSERT_EACH_EQUAL_FLOAT(-0.253f, p0, 4);
1145 VERIFY_FAILS_END
1146 #endif
1147 }
1148
testNotEqualFloatEachEqualNegative2(void)1149 void testNotEqualFloatEachEqualNegative2(void)
1150 {
1151 #ifdef UNITY_EXCLUDE_FLOAT
1152 TEST_IGNORE();
1153 #else
1154 float p0[] = {-25.4f, -8.0f, -25.4f, -25.4f};
1155
1156 EXPECT_ABORT_BEGIN
1157 TEST_ASSERT_EACH_EQUAL_FLOAT(-25.4f, p0, 4);
1158 VERIFY_FAILS_END
1159 #endif
1160 }
1161
testNotEqualFloatEachEqualNegative3(void)1162 void testNotEqualFloatEachEqualNegative3(void)
1163 {
1164 #ifdef UNITY_EXCLUDE_FLOAT
1165 TEST_IGNORE();
1166 #else
1167 float p0[] = {-8.0f, -8.0f, -8.0f, -0.253f};
1168
1169 EXPECT_ABORT_BEGIN
1170 TEST_ASSERT_EACH_EQUAL_FLOAT(-8.0f, p0, 4);
1171 VERIFY_FAILS_END
1172 #endif
1173 }
1174
testEqualFloatEachEqualNaN(void)1175 void testEqualFloatEachEqualNaN(void)
1176 {
1177 #ifdef UNITY_EXCLUDE_FLOAT
1178 TEST_IGNORE();
1179 #else
1180 float p0[] = {0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero};
1181
1182 TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f / f_zero, p0, 4);
1183 #endif
1184 }
1185
testEqualFloatEachEqualInf(void)1186 void testEqualFloatEachEqualInf(void)
1187 {
1188 #ifdef UNITY_EXCLUDE_FLOAT
1189 TEST_IGNORE();
1190 #else
1191 float p0[] = {1.0f / f_zero, 1.0f / f_zero, 25.4f, 0.253f};
1192
1193 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f / f_zero, p0, 2);
1194 #endif
1195 }
1196
testNotEqualFloatEachEqualLengthZero(void)1197 void testNotEqualFloatEachEqualLengthZero(void)
1198 {
1199 #ifdef UNITY_EXCLUDE_FLOAT
1200 TEST_IGNORE();
1201 #else
1202 float p0[1] = {0.0f};
1203
1204 EXPECT_ABORT_BEGIN
1205 TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f, p0, 0);
1206 VERIFY_FAILS_END
1207 #endif
1208 }
1209
testFloatPrinting(void)1210 void testFloatPrinting(void)
1211 {
1212 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
1213 TEST_IGNORE();
1214 #else
1215 TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0f);
1216 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499f);
1217 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.100469499f);
1218 TEST_ASSERT_EQUAL_PRINT_FLOATING("2", 1.9999995f); /*Rounding to int place*/
1219 TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0f);
1220 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f);
1221 TEST_ASSERT_EQUAL_PRINT_FLOATING("7.999999", 7.999999f); /*Not rounding*/
1222 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00002", 16.00002f);
1223 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00004", 16.00004f);
1224 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00006", 16.00006f);
1225 TEST_ASSERT_EQUAL_PRINT_FLOATING("9999999", 9999999.0f); /*Last full print integer*/
1226
1227 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0", -0.0f);
1228 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499f);
1229 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.100469499f);
1230 TEST_ASSERT_EQUAL_PRINT_FLOATING("-2", -1.9999995f); /*Rounding to int place*/
1231 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0f);
1232 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f);
1233 TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.999999", -7.999999f); /*Not rounding*/
1234 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00002", -16.00002f);
1235 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00004", -16.00004f);
1236 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00006", -16.00006f);
1237 TEST_ASSERT_EQUAL_PRINT_FLOATING("-9999999", -9999999.0f); /*Last full print integer*/
1238
1239 /* Fails, prints "4.294968e+09" due to FP math imprecision
1240 * TEST_ASSERT_EQUAL_PRINT_FLOATING("4.294967e+09", 4294967296.0f); */
1241 TEST_ASSERT_EQUAL_PRINT_FLOATING("5e+09", 5000000000.0f);
1242 TEST_ASSERT_EQUAL_PRINT_FLOATING("8e+09", 8.0e+09f);
1243 TEST_ASSERT_EQUAL_PRINT_FLOATING("8.309999e+09", 8309999104.0f);
1244 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 1.0e+10f);
1245 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000000.0f);
1246 /* Some compilers have trouble with inexact float constants, a float cast works generally */
1247 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.000055e+10", (float)1.000055e+10f);
1248 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f);
1249 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.635299e+10", 1.63529943e+10f);
1250 /* Fails, prints "3.402824e+38" due to FP math imprecision
1251 * TEST_ASSERT_EQUAL_PRINT_FLOATING("3.402823e+38", 3.40282346638e38f); */
1252
1253 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1e+10", -1.0e+10f);
1254 /* Fails, prints "-3.402824e+38" due to FP math imprecision
1255 * TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.402823e+38", -3.40282346638e38f); */
1256 #endif
1257 }
1258
testFloatPrintingRoundTiesToEven(void)1259 void testFloatPrintingRoundTiesToEven(void)
1260 {
1261 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
1262 TEST_IGNORE();
1263 #else
1264 #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
1265 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882813", 0.00048828125f);
1266 TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.3", 488281.25f);
1267 TEST_ASSERT_EQUAL_PRINT_FLOATING("5.000001e-07", 0.00000050000005f);
1268 TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.000001e-07", -0.00000050000005f);
1269 #else /* Default to Round ties to even */
1270 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882812", 0.00048828125f);
1271 TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.2", 488281.25f);
1272 TEST_ASSERT_EQUAL_PRINT_FLOATING("5e-07", 0.00000050000005f);
1273 TEST_ASSERT_EQUAL_PRINT_FLOATING("-5e-07", -0.00000050000005f);
1274 #endif
1275 #endif
1276 }
1277
testFloatPrintingInfinityAndNaN(void)1278 void testFloatPrintingInfinityAndNaN(void)
1279 {
1280 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
1281 TEST_IGNORE();
1282 #else
1283 TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0f / f_zero);
1284 TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0f / f_zero);
1285
1286 TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0f / f_zero);
1287 #endif
1288 }
1289
1290 #if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY)
1291 #ifdef UNITY_INCLUDE_DOUBLE
printFloatValue(float f)1292 static void printFloatValue(float f)
1293 {
1294 char expected[18];
1295
1296 startPutcharSpy();
1297 UnityPrintFloat(f);
1298
1299 sprintf(expected, "%.9g", f);
1300 /* We print all NaN's as "nan", not "-nan" */
1301 if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan");
1302
1303 if (strcmp(expected, getBufferPutcharSpy()))
1304 {
1305 /* Fail with diagnostic printing */
1306 TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f);
1307 }
1308 }
1309 #else
printFloatValue(float f)1310 static void printFloatValue(float f)
1311 {
1312 char expected[18];
1313 char expected_lower[18];
1314 char expected_lower2[18];
1315 char expected_lower3[18];
1316 char expected_higher[18];
1317 char expected_higher2[18];
1318 char expected_higher3[18];
1319
1320 startPutcharSpy();
1321 UnityPrintFloat(f);
1322
1323 sprintf(expected, "%.7g", f);
1324 /* We print all NaN's as "nan", not "-nan" */
1325 if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan");
1326
1327 strcpy(expected_lower, expected);
1328 strcpy(expected_lower2, expected);
1329 strcpy(expected_lower3, expected);
1330 strcpy(expected_higher, expected);
1331 strcpy(expected_higher2, expected);
1332 strcpy(expected_higher3, expected);
1333
1334 /* Allow for rounding differences in the last digit */
1335 double lower = (double)f * 0.99999995;
1336 double higher = (double)f * 1.00000005;
1337
1338 if(isfinite(lower)) sprintf(expected_lower, "%.7g", lower);
1339 if(isfinite(higher)) sprintf(expected_higher, "%.7g", higher);
1340
1341 /* Outside [1,10000000] allow for relative error of +/-2.5e-7 */
1342 if (f < 1.0 || f > 10000000)
1343 {
1344 double lower2 = (double)f * 0.99999985;
1345 double lower3 = (double)f * 0.99999975;
1346 double higher2 = (double)f * 1.00000015;
1347 double higher3 = (double)f * 1.00000025;
1348
1349 if (isfinite(lower2)) sprintf(expected_lower2, "%.7g", lower2);
1350 if (isfinite(lower3)) sprintf(expected_lower3, "%.7g", lower3);
1351 if (isfinite(higher2)) sprintf(expected_higher2, "%.7g", higher2);
1352 if (isfinite(higher3)) sprintf(expected_higher3, "%.7g", higher3);
1353 }
1354
1355 if (strcmp(expected, getBufferPutcharSpy()) != 0 &&
1356 strcmp(expected_lower, getBufferPutcharSpy()) != 0 &&
1357 strcmp(expected_lower2, getBufferPutcharSpy()) != 0 &&
1358 strcmp(expected_lower3, getBufferPutcharSpy()) != 0 &&
1359 strcmp(expected_higher, getBufferPutcharSpy()) != 0 &&
1360 strcmp(expected_higher2, getBufferPutcharSpy()) != 0 &&
1361 strcmp(expected_higher3, getBufferPutcharSpy()) != 0)
1362 {
1363 /* Fail with diagnostic printing */
1364 TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f);
1365 }
1366 }
1367 #endif
1368 #endif
1369
testFloatPrintingRandomSamples(void)1370 void testFloatPrintingRandomSamples(void)
1371 {
1372 #if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY)
1373 TEST_IGNORE();
1374 #else
1375 union { float f_value; uint32_t int_value; } u;
1376
1377 /* These values are not covered by the MINSTD generator */
1378 u.int_value = 0x00000000; printFloatValue(u.f_value);
1379 u.int_value = 0x80000000; printFloatValue(u.f_value);
1380 u.int_value = 0x7fffffff; printFloatValue(u.f_value);
1381 u.int_value = 0xffffffff; printFloatValue(u.f_value);
1382
1383 uint32_t a = 1;
1384 for(int num_tested = 0; num_tested < 1000000; num_tested++)
1385 {
1386 /* MINSTD pseudo-random number generator */
1387 a = (uint32_t)(((uint64_t)a * 48271u) % 2147483647u);
1388
1389 /* MINSTD does not set the highest bit; test both possibilities */
1390 u.int_value = a; printFloatValue(u.f_value);
1391 u.int_value = a | 0x80000000; printFloatValue(u.f_value);
1392 }
1393 #endif
1394 }
1395