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
testDoublesWithinDelta(void)36 void testDoublesWithinDelta(void)
37 {
38 #ifdef UNITY_EXCLUDE_DOUBLE
39 TEST_IGNORE();
40 #else
41 TEST_ASSERT_DOUBLE_WITHIN(0.00003, 187245.03485, 187245.03488);
42 TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0);
43 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049);
44 TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424);
45
46 EXPECT_ABORT_BEGIN
47 TEST_ASSERT_DOUBLE_NOT_WITHIN(0.05, 9273.2549, 9273.2049);
48 VERIFY_FAILS_END
49 #endif
50 }
51
testDoublesNotWithinDelta(void)52 void testDoublesNotWithinDelta(void)
53 {
54 #ifdef UNITY_EXCLUDE_DOUBLE
55 TEST_IGNORE();
56 #else
57 TEST_ASSERT_DOUBLE_NOT_WITHIN(0.05, 9273.2649, 9273.2049);
58
59 EXPECT_ABORT_BEGIN
60 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049);
61 VERIFY_FAILS_END
62 #endif
63 }
64
65
testDoublesEqual(void)66 void testDoublesEqual(void)
67 {
68 #ifdef UNITY_EXCLUDE_DOUBLE
69 TEST_IGNORE();
70 #else
71 TEST_ASSERT_EQUAL_DOUBLE(187245123456.0, 187245123456.0);
72 TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6);
73 TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699);
74 TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374);
75
76 EXPECT_ABORT_BEGIN
77 TEST_ASSERT_NOT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374);
78 VERIFY_FAILS_END
79 #endif
80 }
81
testDoublesNotEqual(void)82 void testDoublesNotEqual(void)
83 {
84 #ifdef UNITY_EXCLUDE_DOUBLE
85 TEST_IGNORE();
86 #else
87 TEST_ASSERT_NOT_EQUAL_DOUBLE(9273.9649, 9273.0049);
88
89 EXPECT_ABORT_BEGIN
90 TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049);
91 VERIFY_FAILS_END
92 #endif
93 }
94
testDoublesNotEqualNegative1(void)95 void testDoublesNotEqualNegative1(void)
96 {
97 #ifdef UNITY_EXCLUDE_DOUBLE
98 TEST_IGNORE();
99 #else
100 TEST_ASSERT_NOT_EQUAL_DOUBLE(-9273.9649, -9273.0049);
101
102 EXPECT_ABORT_BEGIN
103 TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049);
104 VERIFY_FAILS_END
105 #endif
106 }
107
testDoublesNotEqualNegative2(void)108 void testDoublesNotEqualNegative2(void)
109 {
110 #ifdef UNITY_EXCLUDE_DOUBLE
111 TEST_IGNORE();
112 #else
113 TEST_ASSERT_NOT_EQUAL_DOUBLE(-9273.0049, -9273.9649);
114
115 EXPECT_ABORT_BEGIN
116 TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649);
117 VERIFY_FAILS_END
118 #endif
119 }
120
testDoublesNotEqualActualNaN(void)121 void testDoublesNotEqualActualNaN(void)
122 {
123 #ifdef UNITY_EXCLUDE_DOUBLE
124 TEST_IGNORE();
125 #else
126 TEST_ASSERT_NOT_EQUAL_DOUBLE(85.963, 0.0 / d_zero);
127
128 EXPECT_ABORT_BEGIN
129 TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero);
130 VERIFY_FAILS_END
131 #endif
132 }
133
testDoublesNotEqualExpectedNaN(void)134 void testDoublesNotEqualExpectedNaN(void)
135 {
136 #ifdef UNITY_EXCLUDE_DOUBLE
137 TEST_IGNORE();
138 #else
139 TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 85.963);
140
141 EXPECT_ABORT_BEGIN
142 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963);
143 VERIFY_FAILS_END
144 #endif
145 }
146
testDoublesEqualBothNaN(void)147 void testDoublesEqualBothNaN(void)
148 {
149 #ifdef UNITY_EXCLUDE_DOUBLE
150 TEST_IGNORE();
151 #else
152 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
153
154 EXPECT_ABORT_BEGIN
155 TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
156 VERIFY_FAILS_END
157 #endif
158 }
159
testDoublesNotEqualInfNaN(void)160 void testDoublesNotEqualInfNaN(void)
161 {
162 #ifdef UNITY_EXCLUDE_DOUBLE
163 TEST_IGNORE();
164 #else
165 TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero);
166
167 EXPECT_ABORT_BEGIN
168 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero);
169 VERIFY_FAILS_END
170 #endif
171 }
172
testDoublesNotEqualNaNInf(void)173 void testDoublesNotEqualNaNInf(void)
174 {
175 #ifdef UNITY_EXCLUDE_DOUBLE
176 TEST_IGNORE();
177 #else
178 TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero);
179
180 EXPECT_ABORT_BEGIN
181 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero);
182 VERIFY_FAILS_END
183 #endif
184 }
185
testDoublesNotEqualActualInf(void)186 void testDoublesNotEqualActualInf(void)
187 {
188 #ifdef UNITY_EXCLUDE_DOUBLE
189 TEST_IGNORE();
190 #else
191 TEST_ASSERT_NOT_EQUAL_DOUBLE(321.642, 1.0 / d_zero);
192
193 EXPECT_ABORT_BEGIN
194 TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero);
195 VERIFY_FAILS_END
196 #endif
197 }
198
testDoublesNotEqualExpectedInf(void)199 void testDoublesNotEqualExpectedInf(void)
200 {
201 #ifdef UNITY_EXCLUDE_DOUBLE
202 TEST_IGNORE();
203 #else
204 TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 321.642);
205
206 EXPECT_ABORT_BEGIN
207 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642);
208 VERIFY_FAILS_END
209 #endif
210 }
211
testDoublesEqualBothInf(void)212 void testDoublesEqualBothInf(void)
213 {
214 #ifdef UNITY_EXCLUDE_DOUBLE
215 TEST_IGNORE();
216 #else
217 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
218
219 EXPECT_ABORT_BEGIN
220 TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
221 VERIFY_FAILS_END
222 #endif
223 }
224
testDoublesNotEqualPlusMinusInf(void)225 void testDoublesNotEqualPlusMinusInf(void)
226 {
227 #ifdef UNITY_EXCLUDE_DOUBLE
228 TEST_IGNORE();
229 #else
230 TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
231
232 EXPECT_ABORT_BEGIN
233 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
234 VERIFY_FAILS_END
235 #endif
236 }
237
testDoublesGreaterThan(void)238 void testDoublesGreaterThan(void)
239 {
240 #ifdef UNITY_EXCLUDE_DOUBLE
241 TEST_IGNORE();
242 #else
243 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 2.0);
244 TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0, 1.0);
245 TEST_ASSERT_GREATER_THAN_DOUBLE(-2.0, -1.0);
246 #endif
247 }
248
testDoublesGreaterThanInf(void)249 void testDoublesGreaterThanInf(void)
250 {
251 #ifdef UNITY_EXCLUDE_DOUBLE
252 TEST_IGNORE();
253 #else
254 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 1.0 / d_zero);
255 TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, 1.0 / d_zero);
256 TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, 1.0);
257 #endif
258 }
259
testDoublesNotGreaterThan(void)260 void testDoublesNotGreaterThan(void)
261 {
262 #ifdef UNITY_EXCLUDE_DOUBLE
263 TEST_IGNORE();
264 #else
265 EXPECT_ABORT_BEGIN
266 TEST_ASSERT_GREATER_THAN_DOUBLE(2.0, 1.0);
267 VERIFY_FAILS_END
268 #endif
269 }
270
testDoublesNotGreaterThanNanActual(void)271 void testDoublesNotGreaterThanNanActual(void)
272 {
273 #ifdef UNITY_EXCLUDE_DOUBLE
274 TEST_IGNORE();
275 #else
276 EXPECT_ABORT_BEGIN
277 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 0.0 / d_zero);
278 VERIFY_FAILS_END
279 #endif
280 }
281
testDoublesNotGreaterThanNanThreshold(void)282 void testDoublesNotGreaterThanNanThreshold(void)
283 {
284 #ifdef UNITY_EXCLUDE_DOUBLE
285 TEST_IGNORE();
286 #else
287 EXPECT_ABORT_BEGIN
288 TEST_ASSERT_GREATER_THAN_DOUBLE(0.0 / d_zero, 1.0);
289 VERIFY_FAILS_END
290 #endif
291 }
292
testDoublesNotGreaterThanNanBoth(void)293 void testDoublesNotGreaterThanNanBoth(void)
294 {
295 #ifdef UNITY_EXCLUDE_DOUBLE
296 TEST_IGNORE();
297 #else
298 EXPECT_ABORT_BEGIN
299 TEST_ASSERT_GREATER_THAN_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
300 VERIFY_FAILS_END
301 #endif
302 }
303
testDoublesNotGreaterThanInfActual(void)304 void testDoublesNotGreaterThanInfActual(void)
305 {
306 #ifdef UNITY_EXCLUDE_DOUBLE
307 TEST_IGNORE();
308 #else
309 EXPECT_ABORT_BEGIN
310 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0 / d_zero, 1.0);
311 VERIFY_FAILS_END
312 #endif
313 }
314
testDoublesNotGreaterThanNegInf(void)315 void testDoublesNotGreaterThanNegInf(void)
316 {
317 #ifdef UNITY_EXCLUDE_DOUBLE
318 TEST_IGNORE();
319 #else
320 EXPECT_ABORT_BEGIN
321 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, -1.0 / d_zero);
322 VERIFY_FAILS_END
323 #endif
324 }
325
testDoublesNotGreaterThanBothInf(void)326 void testDoublesNotGreaterThanBothInf(void)
327 {
328 #ifdef UNITY_EXCLUDE_DOUBLE
329 TEST_IGNORE();
330 #else
331 EXPECT_ABORT_BEGIN
332 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
333 VERIFY_FAILS_END
334 #endif
335 }
336
testDoublesNotGreaterThanBothNegInf(void)337 void testDoublesNotGreaterThanBothNegInf(void)
338 {
339 #ifdef UNITY_EXCLUDE_DOUBLE
340 TEST_IGNORE();
341 #else
342 EXPECT_ABORT_BEGIN
343 TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, -1.0 / d_zero);
344 VERIFY_FAILS_END
345 #endif
346 }
347
testDoublesGreaterOrEqual(void)348 void testDoublesGreaterOrEqual(void)
349 {
350 #ifdef UNITY_EXCLUDE_DOUBLE
351 TEST_IGNORE();
352 #else
353 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 2.0);
354 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(2.0, 2.0);
355 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0, 1.0);
356 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-2.0, -1.0);
357 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-2.0, -2.0);
358 #endif
359 }
360
testDoublesGreaterOrEqualInf(void)361 void testDoublesGreaterOrEqualInf(void)
362 {
363 #ifdef UNITY_EXCLUDE_DOUBLE
364 TEST_IGNORE();
365 #else
366 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 1.0 / d_zero);
367 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0 / d_zero);
368 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0);
369 #endif
370 }
371
testDoublesNotGreaterOrEqual(void)372 void testDoublesNotGreaterOrEqual(void)
373 {
374 #ifdef UNITY_EXCLUDE_DOUBLE
375 TEST_IGNORE();
376 #else
377 EXPECT_ABORT_BEGIN
378 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(2.0, 1.0);
379 VERIFY_FAILS_END
380 #endif
381 }
382
testDoublesNotGreaterOrEqualNanActual(void)383 void testDoublesNotGreaterOrEqualNanActual(void)
384 {
385 #ifdef UNITY_EXCLUDE_DOUBLE
386 TEST_IGNORE();
387 #else
388 EXPECT_ABORT_BEGIN
389 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 0.0 / d_zero);
390 VERIFY_FAILS_END
391 #endif
392 }
393
testDoublesNotGreaterOrEqualNanThreshold(void)394 void testDoublesNotGreaterOrEqualNanThreshold(void)
395 {
396 #ifdef UNITY_EXCLUDE_DOUBLE
397 TEST_IGNORE();
398 #else
399 EXPECT_ABORT_BEGIN
400 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(0.0 / d_zero, 1.0);
401 VERIFY_FAILS_END
402 #endif
403 }
404
testDoublesGreaterOrEqualNanBoth(void)405 void testDoublesGreaterOrEqualNanBoth(void)
406 {
407 #ifdef UNITY_EXCLUDE_DOUBLE
408 TEST_IGNORE();
409 #else
410 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
411 #endif
412 }
413
testDoublesNotGreaterOrEqualInfActual(void)414 void testDoublesNotGreaterOrEqualInfActual(void)
415 {
416 #ifdef UNITY_EXCLUDE_DOUBLE
417 TEST_IGNORE();
418 #else
419 EXPECT_ABORT_BEGIN
420 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0);
421 VERIFY_FAILS_END
422 #endif
423 }
424
testDoublesNotGreaterOrEqualNegInf(void)425 void testDoublesNotGreaterOrEqualNegInf(void)
426 {
427 #ifdef UNITY_EXCLUDE_DOUBLE
428 TEST_IGNORE();
429 #else
430 EXPECT_ABORT_BEGIN
431 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, -1.0 / d_zero);
432 VERIFY_FAILS_END
433 #endif
434 }
435
testDoublesGreaterOrEqualBothInf(void)436 void testDoublesGreaterOrEqualBothInf(void)
437 {
438 #ifdef UNITY_EXCLUDE_DOUBLE
439 TEST_IGNORE();
440 #else
441 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
442 #endif
443 }
444
testDoublesGreaterOrEqualBothNegInf(void)445 void testDoublesGreaterOrEqualBothNegInf(void)
446 {
447 #ifdef UNITY_EXCLUDE_DOUBLE
448 TEST_IGNORE();
449 #else
450 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, -1.0 / d_zero);
451 #endif
452 }
453
testDoublesLessThan(void)454 void testDoublesLessThan(void)
455 {
456 #ifdef UNITY_EXCLUDE_DOUBLE
457 TEST_IGNORE();
458 #else
459 TEST_ASSERT_LESS_THAN_DOUBLE(2.0, 1.0);
460 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, -1.0);
461 TEST_ASSERT_LESS_THAN_DOUBLE(-1.0, -2.0);
462 #endif
463 }
464
testDoublesLessThanInf(void)465 void testDoublesLessThanInf(void)
466 {
467 #ifdef UNITY_EXCLUDE_DOUBLE
468 TEST_IGNORE();
469 #else
470 TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, 1.0);
471 TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
472 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, -1.0 / d_zero);
473 #endif
474 }
475
testDoublesNotLessThan(void)476 void testDoublesNotLessThan(void)
477 {
478 #ifdef UNITY_EXCLUDE_DOUBLE
479 TEST_IGNORE();
480 #else
481 EXPECT_ABORT_BEGIN
482 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 2.0);
483 VERIFY_FAILS_END
484 #endif
485 }
486
testDoublesNotLessThanNanActual(void)487 void testDoublesNotLessThanNanActual(void)
488 {
489 #ifdef UNITY_EXCLUDE_DOUBLE
490 TEST_IGNORE();
491 #else
492 EXPECT_ABORT_BEGIN
493 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 0.0 / d_zero);
494 VERIFY_FAILS_END
495 #endif
496 }
497
testDoublesNotLessThanNanThreshold(void)498 void testDoublesNotLessThanNanThreshold(void)
499 {
500 #ifdef UNITY_EXCLUDE_DOUBLE
501 TEST_IGNORE();
502 #else
503 EXPECT_ABORT_BEGIN
504 TEST_ASSERT_LESS_THAN_DOUBLE(0.0 / d_zero, 1.0);
505 VERIFY_FAILS_END
506 #endif
507 }
508
testDoublesNotLessThanNanBoth(void)509 void testDoublesNotLessThanNanBoth(void)
510 {
511 #ifdef UNITY_EXCLUDE_DOUBLE
512 TEST_IGNORE();
513 #else
514 EXPECT_ABORT_BEGIN
515 TEST_ASSERT_LESS_THAN_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
516 VERIFY_FAILS_END
517 #endif
518 }
519
testDoublesNotLessThanInf(void)520 void testDoublesNotLessThanInf(void)
521 {
522 #ifdef UNITY_EXCLUDE_DOUBLE
523 TEST_IGNORE();
524 #else
525 EXPECT_ABORT_BEGIN
526 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 1.0 / d_zero);
527 VERIFY_FAILS_END
528 #endif
529 }
530
testDoublesNotLessThanNegInf(void)531 void testDoublesNotLessThanNegInf(void)
532 {
533 #ifdef UNITY_EXCLUDE_DOUBLE
534 TEST_IGNORE();
535 #else
536 EXPECT_ABORT_BEGIN
537 TEST_ASSERT_LESS_THAN_DOUBLE(-1.0 / d_zero, 1.0);
538 VERIFY_FAILS_END
539 #endif
540 }
541
testDoublesNotLessThanBothInf(void)542 void testDoublesNotLessThanBothInf(void)
543 {
544 #ifdef UNITY_EXCLUDE_DOUBLE
545 TEST_IGNORE();
546 #else
547 EXPECT_ABORT_BEGIN
548 TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
549 VERIFY_FAILS_END
550 #endif
551 }
552
testDoublesNotLessThanBothNegInf(void)553 void testDoublesNotLessThanBothNegInf(void)
554 {
555 #ifdef UNITY_EXCLUDE_DOUBLE
556 TEST_IGNORE();
557 #else
558 EXPECT_ABORT_BEGIN
559 TEST_ASSERT_LESS_THAN_DOUBLE(-1.0 / d_zero, -1.0 / d_zero);
560 VERIFY_FAILS_END
561 #endif
562 }
563
testDoublesLessOrEqual(void)564 void testDoublesLessOrEqual(void)
565 {
566 #ifdef UNITY_EXCLUDE_DOUBLE
567 TEST_IGNORE();
568 #else
569 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(2.0, 1.0);
570 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(2.0, 2.0);
571 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, -1.0);
572 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0, -2.0);
573 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-2.0, -2.0);
574 #endif
575 }
576
testDoublesLessOrEqualInf(void)577 void testDoublesLessOrEqualInf(void)
578 {
579 #ifdef UNITY_EXCLUDE_DOUBLE
580 TEST_IGNORE();
581 #else
582 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0);
583 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
584 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, -1.0 / d_zero);
585 #endif
586 }
587
testDoublesNotLessOrEqual(void)588 void testDoublesNotLessOrEqual(void)
589 {
590 #ifdef UNITY_EXCLUDE_DOUBLE
591 TEST_IGNORE();
592 #else
593 EXPECT_ABORT_BEGIN
594 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 2.0);
595 VERIFY_FAILS_END
596 #endif
597 }
598
testDoublesNotLessOrEqualNanActual(void)599 void testDoublesNotLessOrEqualNanActual(void)
600 {
601 #ifdef UNITY_EXCLUDE_DOUBLE
602 TEST_IGNORE();
603 #else
604 EXPECT_ABORT_BEGIN
605 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 0.0 / d_zero);
606 VERIFY_FAILS_END
607 #endif
608 }
609
testDoublesNotLessOrEqualNanThreshold(void)610 void testDoublesNotLessOrEqualNanThreshold(void)
611 {
612 #ifdef UNITY_EXCLUDE_DOUBLE
613 TEST_IGNORE();
614 #else
615 EXPECT_ABORT_BEGIN
616 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(0.0 / d_zero, 1.0);
617 VERIFY_FAILS_END
618 #endif
619 }
620
testDoublesLessOrEqualNanBoth(void)621 void testDoublesLessOrEqualNanBoth(void)
622 {
623 #ifdef UNITY_EXCLUDE_DOUBLE
624 TEST_IGNORE();
625 #else
626 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
627 #endif
628 }
629
testDoublesNotLessOrEqualInf(void)630 void testDoublesNotLessOrEqualInf(void)
631 {
632 #ifdef UNITY_EXCLUDE_DOUBLE
633 TEST_IGNORE();
634 #else
635 EXPECT_ABORT_BEGIN
636 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 1.0 / d_zero);
637 VERIFY_FAILS_END
638 #endif
639 }
640
testDoublesNotLessOrEqualNegInf(void)641 void testDoublesNotLessOrEqualNegInf(void)
642 {
643 #ifdef UNITY_EXCLUDE_DOUBLE
644 TEST_IGNORE();
645 #else
646 EXPECT_ABORT_BEGIN
647 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0);
648 VERIFY_FAILS_END
649 #endif
650 }
651
testDoublesLessOrEqualBothInf(void)652 void testDoublesLessOrEqualBothInf(void)
653 {
654 #ifdef UNITY_EXCLUDE_DOUBLE
655 TEST_IGNORE();
656 #else
657 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
658 #endif
659 }
660
testDoublesLessOrEqualBothNegInf(void)661 void testDoublesLessOrEqualBothNegInf(void)
662 {
663 #ifdef UNITY_EXCLUDE_DOUBLE
664 TEST_IGNORE();
665 #else
666 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0 / d_zero, -1.0 / d_zero);
667 #endif
668 }
669
testDoubleIsPosInf1(void)670 void testDoubleIsPosInf1(void)
671 {
672 #ifdef UNITY_EXCLUDE_DOUBLE
673 TEST_IGNORE();
674 #else
675 TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero);
676 #endif
677 }
678
testDoubleIsPosInf2(void)679 void testDoubleIsPosInf2(void)
680 {
681 #ifdef UNITY_EXCLUDE_DOUBLE
682 TEST_IGNORE();
683 #else
684 EXPECT_ABORT_BEGIN
685 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero);
686 VERIFY_FAILS_END
687 #endif
688 }
689
testDoubleIsNegInf1(void)690 void testDoubleIsNegInf1(void)
691 {
692 #ifdef UNITY_EXCLUDE_DOUBLE
693 TEST_IGNORE();
694 #else
695 TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero);
696 #endif
697 }
698
testDoubleIsNegInf2(void)699 void testDoubleIsNegInf2(void)
700 {
701 #ifdef UNITY_EXCLUDE_DOUBLE
702 TEST_IGNORE();
703 #else
704 EXPECT_ABORT_BEGIN
705 TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero);
706 VERIFY_FAILS_END
707 #endif
708 }
709
testDoubleIsNotPosInf1(void)710 void testDoubleIsNotPosInf1(void)
711 {
712 #ifdef UNITY_EXCLUDE_DOUBLE
713 TEST_IGNORE();
714 #else
715 EXPECT_ABORT_BEGIN
716 TEST_ASSERT_DOUBLE_IS_INF(2.0);
717 VERIFY_FAILS_END
718 #endif
719 }
720
testDoubleIsNotPosInf2(void)721 void testDoubleIsNotPosInf2(void)
722 {
723 #ifdef UNITY_EXCLUDE_DOUBLE
724 TEST_IGNORE();
725 #else
726 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0);
727 #endif
728 }
729
testDoubleIsNotNegInf(void)730 void testDoubleIsNotNegInf(void)
731 {
732 #ifdef UNITY_EXCLUDE_DOUBLE
733 TEST_IGNORE();
734 #else
735 EXPECT_ABORT_BEGIN
736 TEST_ASSERT_DOUBLE_IS_NEG_INF(-999.876);
737 VERIFY_FAILS_END
738 #endif
739 }
740
testDoubleIsNan1(void)741 void testDoubleIsNan1(void)
742 {
743 #ifdef UNITY_EXCLUDE_DOUBLE
744 TEST_IGNORE();
745 #else
746 TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero);
747 #endif
748 }
749
testDoubleIsNan2(void)750 void testDoubleIsNan2(void)
751 {
752 #ifdef UNITY_EXCLUDE_DOUBLE
753 TEST_IGNORE();
754 #else
755 EXPECT_ABORT_BEGIN
756 TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero);
757 VERIFY_FAILS_END
758 #endif
759 }
760
testDoubleIsNotNan1(void)761 void testDoubleIsNotNan1(void)
762 {
763 #ifdef UNITY_EXCLUDE_DOUBLE
764 TEST_IGNORE();
765 #else
766 EXPECT_ABORT_BEGIN
767 TEST_ASSERT_DOUBLE_IS_NAN(234.9);
768 VERIFY_FAILS_END
769 #endif
770 }
771
testDoubleIsNotNan2(void)772 void testDoubleIsNotNan2(void)
773 {
774 #ifdef UNITY_EXCLUDE_DOUBLE
775 TEST_IGNORE();
776 #else
777 TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9);
778 #endif
779 }
780
testDoubleInfIsNotNan(void)781 void testDoubleInfIsNotNan(void)
782 {
783 #ifdef UNITY_EXCLUDE_DOUBLE
784 TEST_IGNORE();
785 #else
786 EXPECT_ABORT_BEGIN
787 TEST_ASSERT_DOUBLE_IS_NAN(1.0 / d_zero);
788 VERIFY_FAILS_END
789 #endif
790 }
791
testDoubleNanIsNotInf(void)792 void testDoubleNanIsNotInf(void)
793 {
794 #ifdef UNITY_EXCLUDE_DOUBLE
795 TEST_IGNORE();
796 #else
797 EXPECT_ABORT_BEGIN
798 TEST_ASSERT_DOUBLE_IS_INF(0.0 / d_zero);
799 VERIFY_FAILS_END
800 #endif
801 }
802
testDoubleIsDeterminate1(void)803 void testDoubleIsDeterminate1(void)
804 {
805 #ifdef UNITY_EXCLUDE_DOUBLE
806 TEST_IGNORE();
807 #else
808 TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0);
809 TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3);
810 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3);
811 #endif
812 }
813
testDoubleIsDeterminate2(void)814 void testDoubleIsDeterminate2(void)
815 {
816 #ifdef UNITY_EXCLUDE_DOUBLE
817 TEST_IGNORE();
818 #else
819 EXPECT_ABORT_BEGIN
820 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3);
821 VERIFY_FAILS_END
822 #endif
823 }
824
testDoubleIsNotDeterminate1(void)825 void testDoubleIsNotDeterminate1(void)
826 {
827 #ifdef UNITY_EXCLUDE_DOUBLE
828 TEST_IGNORE();
829 #else
830 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero);
831 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero);
832 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero);
833 #endif
834 }
835
testDoubleIsNotDeterminate2(void)836 void testDoubleIsNotDeterminate2(void)
837 {
838 #ifdef UNITY_EXCLUDE_DOUBLE
839 TEST_IGNORE();
840 #else
841 EXPECT_ABORT_BEGIN
842 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero);
843 VERIFY_FAILS_END
844 #endif
845 }
846
testDoubleTraitFailsOnInvalidTrait(void)847 void testDoubleTraitFailsOnInvalidTrait(void)
848 {
849 #ifdef UNITY_EXCLUDE_DOUBLE
850 TEST_IGNORE();
851 #else
852 EXPECT_ABORT_BEGIN
853 UnityAssertDoubleSpecial(1.0, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT);
854 VERIFY_FAILS_END
855 #endif
856 }
857
testEqualDoubleArrays(void)858 void testEqualDoubleArrays(void)
859 {
860 #ifdef UNITY_EXCLUDE_DOUBLE
861 TEST_IGNORE();
862 #else
863 double p0[] = {1.0, -8.0, 25.4, -0.123};
864 double p1[] = {1.0, -8.0, 25.4, -0.123};
865 double p2[] = {1.0, -8.0, 25.4, -0.2};
866 double p3[] = {1.0, -23.0, 25.0, -0.26};
867
868 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 1);
869 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 4);
870 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
871 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3);
872 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1);
873 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1);
874 #endif
875 }
876
testNotEqualDoubleArraysExpectedNull(void)877 void testNotEqualDoubleArraysExpectedNull(void)
878 {
879 #ifdef UNITY_EXCLUDE_DOUBLE
880 TEST_IGNORE();
881 #else
882 double* p0 = NULL;
883 double p1[] = {1.0, 8.0, 25.4, 0.252};
884
885 EXPECT_ABORT_BEGIN
886 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
887 VERIFY_FAILS_END
888 #endif
889 }
890
testNotEqualDoubleArraysActualNull(void)891 void testNotEqualDoubleArraysActualNull(void)
892 {
893 #ifdef UNITY_EXCLUDE_DOUBLE
894 TEST_IGNORE();
895 #else
896 double p0[] = {1.0, 8.0, 25.4, 0.253};
897 double* p1 = NULL;
898
899 EXPECT_ABORT_BEGIN
900 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
901 VERIFY_FAILS_END
902 #endif
903 }
904
testNotEqualDoubleArrays1(void)905 void testNotEqualDoubleArrays1(void)
906 {
907 #ifdef UNITY_EXCLUDE_DOUBLE
908 TEST_IGNORE();
909 #else
910 double p0[] = {1.0, 8.0, 25.4, 0.25666666667};
911 double p1[] = {1.0, 8.0, 25.4, 0.25666666666};
912
913 EXPECT_ABORT_BEGIN
914 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
915 VERIFY_FAILS_END
916 #endif
917 }
918
testNotEqualDoubleArrays2(void)919 void testNotEqualDoubleArrays2(void)
920 {
921 #ifdef UNITY_EXCLUDE_DOUBLE
922 TEST_IGNORE();
923 #else
924 double p0[] = {1.0, 8.0, 25.4, 0.253};
925 double p1[] = {2.0, 8.0, 25.4, 0.253};
926
927 EXPECT_ABORT_BEGIN
928 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
929 VERIFY_FAILS_END
930 #endif
931 }
932
testNotEqualDoubleArrays3(void)933 void testNotEqualDoubleArrays3(void)
934 {
935 #ifdef UNITY_EXCLUDE_DOUBLE
936 TEST_IGNORE();
937 #else
938 double p0[] = {1.0, 8.0, 25.4, 0.253};
939 double p1[] = {1.0, 8.0, 25.5, 0.253};
940
941 EXPECT_ABORT_BEGIN
942 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
943 VERIFY_FAILS_END
944 #endif
945 }
946
testNotEqualDoubleArraysNegative1(void)947 void testNotEqualDoubleArraysNegative1(void)
948 {
949 #ifdef UNITY_EXCLUDE_DOUBLE
950 TEST_IGNORE();
951 #else
952 double p0[] = {-1.0, -8.0, -25.4, -0.2566666667};
953 double p1[] = {-1.0, -8.0, -25.4, -0.2566666666};
954
955 EXPECT_ABORT_BEGIN
956 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
957 VERIFY_FAILS_END
958 #endif
959 }
960
testNotEqualDoubleArraysNegative2(void)961 void testNotEqualDoubleArraysNegative2(void)
962 {
963 #ifdef UNITY_EXCLUDE_DOUBLE
964 TEST_IGNORE();
965 #else
966 double p0[] = {-1.0, -8.0, -25.4, -0.253};
967 double p1[] = {-2.0, -8.0, -25.4, -0.253};
968
969 EXPECT_ABORT_BEGIN
970 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
971 VERIFY_FAILS_END
972 #endif
973 }
974
testNotEqualDoubleArraysNegative3(void)975 void testNotEqualDoubleArraysNegative3(void)
976 {
977 #ifdef UNITY_EXCLUDE_DOUBLE
978 TEST_IGNORE();
979 #else
980 double p0[] = {-1.0, -8.0, -25.4, -0.253};
981 double p1[] = {-1.0, -8.0, -25.5, -0.253};
982
983 EXPECT_ABORT_BEGIN
984 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
985 VERIFY_FAILS_END
986 #endif
987 }
988
testEqualDoubleArraysNaN(void)989 void testEqualDoubleArraysNaN(void)
990 {
991 #ifdef UNITY_EXCLUDE_DOUBLE
992 TEST_IGNORE();
993 #else
994 double p0[] = {1.0, 0.0 / d_zero, 25.4, 0.253};
995 double p1[] = {1.0, 0.0 / d_zero, 25.4, 0.253};
996
997 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
998 #endif
999 }
1000
testEqualDoubleArraysInf(void)1001 void testEqualDoubleArraysInf(void)
1002 {
1003 #ifdef UNITY_EXCLUDE_DOUBLE
1004 TEST_IGNORE();
1005 #else
1006 double p0[] = {1.0, 1.0 / d_zero, 25.4, 0.253};
1007 double p1[] = {1.0, 1.0 / d_zero, 25.4, 0.253};
1008
1009 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
1010 #endif
1011 }
1012
testNotEqualDoubleArraysLengthZero(void)1013 void testNotEqualDoubleArraysLengthZero(void)
1014 {
1015 #ifdef UNITY_EXCLUDE_DOUBLE
1016 TEST_IGNORE();
1017 #else
1018 double p0[1] = {0.0};
1019 double p1[1] = {0.0};
1020
1021 EXPECT_ABORT_BEGIN
1022 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0);
1023 VERIFY_FAILS_END
1024 #endif
1025 }
1026
testDoubleArraysWithin(void)1027 void testDoubleArraysWithin(void)
1028 {
1029 #ifdef UNITY_EXCLUDE_DOUBLE
1030 TEST_IGNORE();
1031 #else
1032 double p0[] = {1.0, -8.0, 25.4, -0.123};
1033 double p1[] = {1.0, -8.0, 25.4, -0.123};
1034 double p2[] = {1.0, -8.0, 25.4, -0.2};
1035 double p3[] = {1.0, -23.0, 25.0, -0.26};
1036 double p4[] = {2.0, -9.0, 26.2, 0.26};
1037 double p5[] = {-1.0, -7.0, 29.0, 2.6};
1038
1039 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p0, 1);
1040 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p0, 4);
1041 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p1, 4);
1042 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p2, 3);
1043 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p3, 1);
1044 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p4, 1);
1045 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p4, 4);
1046 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(2.0, p0, p5, 1);
1047 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(2.0, p0, p5, 2);
1048 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, NULL, NULL, 1);
1049 #endif
1050 }
1051
testDoubleArraysWithinUnusualDelta(void)1052 void testDoubleArraysWithinUnusualDelta(void)
1053 {
1054 #ifdef UNITY_EXCLUDE_DOUBLE
1055 TEST_IGNORE();
1056 #else
1057 double p0[] = {-INFINITY, -8.0, 25.4, -0.123};
1058 double p1[] = {INFINITY, 10.1};
1059
1060 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(INFINITY, p0, p1, 2);
1061
1062 EXPECT_ABORT_BEGIN
1063 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(NAN, p0, p0, 4);
1064 VERIFY_FAILS_END
1065 #endif
1066 }
1067
testEqualDoubleEachEqual(void)1068 void testEqualDoubleEachEqual(void)
1069 {
1070 #ifdef UNITY_EXCLUDE_DOUBLE
1071 TEST_IGNORE();
1072 #else
1073 double p0[] = {1.0, 1.0, 1.0, 1.0};
1074 double p1[] = {-0.123, -0.123, -0.123, -0.123};
1075 double p2[] = {25.4, 25.4, 25.4, -0.2};
1076 double p3[] = {1.0, -23.0, 25.0, -0.26};
1077
1078 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 1);
1079 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4);
1080 TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.123, p1, 4);
1081 TEST_ASSERT_EACH_EQUAL_DOUBLE(25.4, p2, 3);
1082 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p3, 1);
1083 #endif
1084 }
1085
testNotEqualDoubleEachEqualActualNull(void)1086 void testNotEqualDoubleEachEqualActualNull(void)
1087 {
1088 #ifdef UNITY_EXCLUDE_DOUBLE
1089 TEST_IGNORE();
1090 #else
1091 double* p0 = NULL;
1092
1093 EXPECT_ABORT_BEGIN
1094 TEST_ASSERT_EACH_EQUAL_DOUBLE(5, p0, 4);
1095 VERIFY_FAILS_END
1096 #endif
1097 }
1098
testNotEqualDoubleEachEqual1(void)1099 void testNotEqualDoubleEachEqual1(void)
1100 {
1101 #ifdef UNITY_EXCLUDE_DOUBLE
1102 TEST_IGNORE();
1103 #else
1104 double p0[] = {0.253, 8.0, 0.253, 0.253};
1105
1106 EXPECT_ABORT_BEGIN
1107 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.253, p0, 4);
1108 VERIFY_FAILS_END
1109 #endif
1110 }
1111
testNotEqualDoubleEachEqual2(void)1112 void testNotEqualDoubleEachEqual2(void)
1113 {
1114 #ifdef UNITY_EXCLUDE_DOUBLE
1115 TEST_IGNORE();
1116 #else
1117 double p0[] = {8.0, 8.0, 8.0, 0.253};
1118
1119 EXPECT_ABORT_BEGIN
1120 TEST_ASSERT_EACH_EQUAL_DOUBLE(8.0, p0, 4);
1121 VERIFY_FAILS_END
1122 #endif
1123 }
1124
testNotEqualDoubleEachEqual3(void)1125 void testNotEqualDoubleEachEqual3(void)
1126 {
1127 #ifdef UNITY_EXCLUDE_DOUBLE
1128 TEST_IGNORE();
1129 #else
1130 double p0[] = {1.0, 1.0, 1.0, 0.253};
1131
1132 EXPECT_ABORT_BEGIN
1133 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4);
1134 VERIFY_FAILS_END
1135 #endif
1136 }
1137
testNotEqualDoubleEachEqualNegative1(void)1138 void testNotEqualDoubleEachEqualNegative1(void)
1139 {
1140 #ifdef UNITY_EXCLUDE_DOUBLE
1141 TEST_IGNORE();
1142 #else
1143 double p0[] = {-1.0, -0.253, -0.253, -0.253};
1144
1145 EXPECT_ABORT_BEGIN
1146 TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.253, p0, 4);
1147 VERIFY_FAILS_END
1148 #endif
1149 }
1150
testNotEqualDoubleEachEqualNegative2(void)1151 void testNotEqualDoubleEachEqualNegative2(void)
1152 {
1153 #ifdef UNITY_EXCLUDE_DOUBLE
1154 TEST_IGNORE();
1155 #else
1156 double p0[] = {-25.4, -8.0, -25.4, -25.4};
1157
1158 EXPECT_ABORT_BEGIN
1159 TEST_ASSERT_EACH_EQUAL_DOUBLE(-25.4, p0, 4);
1160 VERIFY_FAILS_END
1161 #endif
1162 }
1163
testNotEqualDoubleEachEqualNegative3(void)1164 void testNotEqualDoubleEachEqualNegative3(void)
1165 {
1166 #ifdef UNITY_EXCLUDE_DOUBLE
1167 TEST_IGNORE();
1168 #else
1169 double p0[] = {-8.0, -8.0, -8.0, -0.253};
1170
1171 EXPECT_ABORT_BEGIN
1172 TEST_ASSERT_EACH_EQUAL_DOUBLE(-8.0, p0, 4);
1173 VERIFY_FAILS_END
1174 #endif
1175 }
1176
testEqualDoubleEachEqualNaN(void)1177 void testEqualDoubleEachEqualNaN(void)
1178 {
1179 #ifdef UNITY_EXCLUDE_DOUBLE
1180 TEST_IGNORE();
1181 #else
1182 double p0[] = {0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero};
1183
1184 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0 / d_zero, p0, 4);
1185 #endif
1186 }
1187
testEqualDoubleEachEqualInf(void)1188 void testEqualDoubleEachEqualInf(void)
1189 {
1190 #ifdef UNITY_EXCLUDE_DOUBLE
1191 TEST_IGNORE();
1192 #else
1193 double p0[] = {1.0 / d_zero, 1.0 / d_zero, 25.4, 0.253};
1194
1195 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0 / d_zero, p0, 2);
1196 #endif
1197 }
1198
testNotEqualDoubleEachEqualLengthZero(void)1199 void testNotEqualDoubleEachEqualLengthZero(void)
1200 {
1201 #ifdef UNITY_EXCLUDE_DOUBLE
1202 TEST_IGNORE();
1203 #else
1204 double p0[1] = {0.0};
1205
1206 EXPECT_ABORT_BEGIN
1207 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0, p0, 0);
1208 VERIFY_FAILS_END
1209 #endif
1210 }
1211
testDoublePrinting(void)1212 void testDoublePrinting(void)
1213 {
1214 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
1215 TEST_IGNORE();
1216 #else
1217 TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0);
1218 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499);
1219 TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0000005e-07", 0.00000050000005);
1220 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469499", 0.100469499);
1221 TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 0.9999999995); /*Rounding to int place*/
1222 TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0);
1223 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25);
1224 TEST_ASSERT_EQUAL_PRINT_FLOATING("7.99999999", 7.99999999); /*Not rounding*/
1225 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000002", 16.0000002);
1226 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000004", 16.0000004);
1227 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000006", 16.0000006);
1228 TEST_ASSERT_EQUAL_PRINT_FLOATING("999999999", 999999999.0); /*Last full print integer*/
1229
1230 TEST_ASSERT_EQUAL_PRINT_FLOATING("0", -0.0); /* -0 no supported on all targets */
1231 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499);
1232 TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.0000005e-07", -0.00000050000005);
1233 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469499", -0.100469499);
1234 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -0.9999999995); /*Rounding to int place*/
1235 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0);
1236 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25);
1237 TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.99999999", -7.99999999); /*Not rounding*/
1238 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000002", -16.0000002);
1239 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000004", -16.0000004);
1240 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000006", -16.0000006);
1241 TEST_ASSERT_EQUAL_PRINT_FLOATING("-999999999", -999999999.0); /*Last full print integer*/
1242
1243 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.10046949999999999);
1244 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967295.9);
1245 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0);
1246 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 9999999995.0);
1247 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199254740990.0);
1248 TEST_ASSERT_EQUAL_PRINT_FLOATING("7e+100", 7.0e+100);
1249 TEST_ASSERT_EQUAL_PRINT_FLOATING("3e+200", 3.0e+200);
1250 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23456789e+300", 9.23456789e+300);
1251
1252 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.10046949999999999);
1253 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967295.9);
1254 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967296.0);
1255 TEST_ASSERT_EQUAL_PRINT_FLOATING("-7e+100", -7.0e+100);
1256 #endif
1257 }
1258
testDoublePrintingRoundTiesToEven(void)1259 void testDoublePrintingRoundTiesToEven(void)
1260 {
1261 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
1262 TEST_IGNORE();
1263 #else
1264 #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
1265 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00000001e+10", 10000000050.0);
1266 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199245000000.0);
1267 #else /* Default to Round ties to even */
1268 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000050.0);
1269 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0);
1270 #endif
1271 #endif
1272 }
1273
testDoublePrintingInfinityAndNaN(void)1274 void testDoublePrintingInfinityAndNaN(void)
1275 {
1276 #if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
1277 TEST_IGNORE();
1278 #else
1279 TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0 / d_zero);
1280 TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0 / d_zero);
1281
1282 TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0 / d_zero);
1283 #endif
1284 }
1285