trackler 2.0.3.2 → 2.0.3.3

Sign up to get free protection for your applications and to get access to all the features.
Files changed (106) hide show
  1. checksums.yaml +4 -4
  2. data/lib/trackler/version.rb +1 -1
  3. data/tracks/c/config.json +10 -0
  4. data/tracks/c/exercises/robot-simulator/makefile +16 -0
  5. data/tracks/c/exercises/robot-simulator/src/example.c +74 -0
  6. data/tracks/c/exercises/robot-simulator/src/robot_simulator.h +41 -0
  7. data/tracks/c/exercises/robot-simulator/test/test_robot_simulator.c +165 -0
  8. data/tracks/c/exercises/robot-simulator/test/vendor/unity.c +1300 -0
  9. data/tracks/c/exercises/robot-simulator/test/vendor/unity.h +274 -0
  10. data/tracks/c/exercises/robot-simulator/test/vendor/unity_internals.h +701 -0
  11. data/tracks/ecmascript/exercises/rna-transcription/example.js +9 -2
  12. data/tracks/ecmascript/exercises/rna-transcription/rna-transcription.spec.js +18 -0
  13. data/tracks/go/exercises/hello-world/example.go +4 -2
  14. data/tracks/go/exercises/hello-world/hello_test.go +4 -4
  15. data/tracks/go/exercises/hello-world/hello_world.go +6 -6
  16. data/tracks/groovy/config.json +5 -0
  17. data/tracks/groovy/exercises/phone-number/Example.groovy +20 -0
  18. data/tracks/groovy/exercises/phone-number/PhoneNumberSpec.groovy +75 -0
  19. data/tracks/haskell/exercises/difference-of-squares/test/Tests.hs +2 -0
  20. data/tracks/java/config.json +13 -1
  21. data/tracks/java/exercises/all-your-base/build.gradle +17 -0
  22. data/tracks/java/exercises/all-your-base/src/example/java/BaseConverter.java +80 -0
  23. data/tracks/java/exercises/all-your-base/src/main/java/BaseConverter.java +5 -0
  24. data/tracks/java/exercises/all-your-base/src/test/java/BaseConverterTest.java +256 -0
  25. data/tracks/java/exercises/binary-search/build.gradle +17 -0
  26. data/tracks/java/exercises/binary-search/src/example/java/BinarySearch.java +40 -0
  27. data/tracks/java/exercises/binary-search/src/main/java/.keep +0 -0
  28. data/tracks/java/exercises/binary-search/src/main/java/BinarySearch.java +4 -0
  29. data/tracks/java/exercises/binary-search/src/test/java/.keep +0 -0
  30. data/tracks/java/exercises/binary-search/src/test/java/BinarySearchTest.java +136 -0
  31. data/tracks/java/exercises/settings.gradle +1 -0
  32. data/tracks/lua/config.json +16 -0
  33. data/tracks/lua/exercises/say/example.lua +92 -0
  34. data/tracks/lua/exercises/say/say_spec.lua +105 -0
  35. data/tracks/lua/exercises/secret-handshake/example.lua +17 -0
  36. data/tracks/lua/exercises/secret-handshake/secret-handshake_spec.lua +38 -0
  37. data/tracks/ocaml/config.json +10 -1
  38. data/tracks/ocaml/exercises/bracket-push/.merlin +3 -0
  39. data/tracks/ocaml/exercises/bracket-push/Makefile +11 -0
  40. data/tracks/ocaml/exercises/bracket-push/bracket_push.mli +3 -0
  41. data/tracks/ocaml/exercises/bracket-push/example.ml +40 -0
  42. data/tracks/ocaml/exercises/bracket-push/test.ml +38 -0
  43. data/tracks/ocaml/exercises/leap/test.ml +7 -7
  44. data/tracks/ocaml/tools/test-generator/Makefile +2 -2
  45. data/tracks/ocaml/tools/test-generator/interfaces/codegen.mli +2 -2
  46. data/tracks/ocaml/tools/test-generator/interfaces/{test_generator.mli → controller.mli} +0 -0
  47. data/tracks/ocaml/tools/test-generator/interfaces/parser.mli +7 -1
  48. data/tracks/ocaml/tools/test-generator/interfaces/special_cases.mli +2 -2
  49. data/tracks/ocaml/tools/test-generator/interfaces/utils.mli +4 -0
  50. data/tracks/ocaml/tools/test-generator/src/codegen.ml +9 -5
  51. data/tracks/ocaml/tools/test-generator/src/{test_generator.ml → controller.ml} +24 -15
  52. data/tracks/ocaml/tools/test-generator/src/model.ml +6 -0
  53. data/tracks/ocaml/tools/test-generator/src/parser.ml +34 -7
  54. data/tracks/ocaml/tools/test-generator/src/special_cases.ml +11 -4
  55. data/tracks/ocaml/tools/test-generator/src/template.ml +49 -6
  56. data/tracks/ocaml/tools/test-generator/src/test_gen.ml +1 -1
  57. data/tracks/ocaml/tools/test-generator/src/utils.ml +6 -0
  58. data/tracks/ocaml/tools/test-generator/templates/anagram/template.ml +2 -2
  59. data/tracks/ocaml/tools/test-generator/templates/bob/template.ml +2 -2
  60. data/tracks/ocaml/tools/test-generator/templates/bracket-push/template.ml +16 -0
  61. data/tracks/ocaml/tools/test-generator/templates/difference-of-squares/template.ml +19 -0
  62. data/tracks/ocaml/tools/test-generator/templates/hamming/template.ml +2 -2
  63. data/tracks/ocaml/tools/test-generator/templates/hello-world/template.ml +2 -2
  64. data/tracks/ocaml/tools/test-generator/templates/leap/template.ml +2 -2
  65. data/tracks/ocaml/tools/test-generator/templates/raindrops/template.ml +2 -2
  66. data/tracks/ocaml/tools/test-generator/templates/say/template.ml +3 -3
  67. data/tracks/ocaml/tools/test-generator/templates/word-count/template.ml +2 -2
  68. data/tracks/ocaml/tools/test-generator/test/all_tests.ml +3 -1
  69. data/tracks/ocaml/tools/test-generator/test/codegen_test.ml +7 -7
  70. data/tracks/ocaml/tools/test-generator/test/difference_of_squares.json +67 -0
  71. data/tracks/ocaml/tools/test-generator/test/hello_world.json +23 -0
  72. data/tracks/ocaml/tools/test-generator/test/parser_test.ml +30 -12
  73. data/tracks/ocaml/tools/test-generator/test/sample-suite-template.txt +16 -0
  74. data/tracks/ocaml/tools/test-generator/test/sample_template.txt +2 -2
  75. data/tracks/ocaml/tools/test-generator/test/special_cases_test.ml +1 -1
  76. data/tracks/ocaml/tools/test-generator/test/template_test.ml +40 -6
  77. data/tracks/perl6/.travis.yml +3 -0
  78. data/tracks/perl6/docs/RESOURCES.md +1 -1
  79. data/tracks/perl6/exercises/accumulate/accumulate.t +3 -7
  80. data/tracks/perl6/exercises/anagram/anagram.t +3 -7
  81. data/tracks/perl6/exercises/binary/binary.t +3 -7
  82. data/tracks/perl6/exercises/bob/bob.t +4 -8
  83. data/tracks/perl6/exercises/grains/grains.t +3 -7
  84. data/tracks/perl6/exercises/leap/leap.t +3 -7
  85. data/tracks/perl6/exercises/rna-transcription/rna_transcription.t +4 -8
  86. data/tracks/perl6/exercises/robot-name/robot.t +4 -8
  87. data/tracks/perl6/exercises/scrabble-score/scrabble_score.t +3 -7
  88. data/tracks/perl6/exercises/word-count/word_count.t +3 -8
  89. data/tracks/r/config.json +10 -0
  90. data/tracks/r/docs/ABOUT.md +14 -0
  91. data/tracks/r/exercises/difference-of-squares/difference-of-squares.R +5 -0
  92. data/tracks/r/exercises/difference-of-squares/example.R +6 -0
  93. data/tracks/r/exercises/difference-of-squares/test_difference-of-squares.R +23 -0
  94. data/tracks/r/exercises/hamming/example.R +8 -0
  95. data/tracks/r/exercises/hamming/hamming.R +4 -0
  96. data/tracks/r/exercises/hamming/test_hamming.R +87 -0
  97. data/tracks/ruby/exercises/binary/.version +1 -1
  98. data/tracks/ruby/exercises/binary/binary_test.rb +17 -19
  99. data/tracks/ruby/exercises/binary/example.rb +13 -13
  100. data/tracks/ruby/exercises/isogram/.version +1 -1
  101. data/tracks/ruby/exercises/isogram/example.rb +1 -1
  102. data/tracks/ruby/exercises/isogram/isogram_test.rb +16 -30
  103. data/tracks/ruby/lib/binary_cases.rb +2 -3
  104. data/tracks/ruby/lib/isogram_cases.rb +1 -5
  105. data/tracks/scala/exercises/phone-number/HINTS.md +9 -0
  106. metadata +45 -4
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 100e83acfd728015ba64135218a06440e7c5afea
4
- data.tar.gz: 9c0c11c2ede2d6ef5f02dfd6ad4b84d29d7288bd
3
+ metadata.gz: 2f53c82944593257de8cc399d3860e5b259356f7
4
+ data.tar.gz: bc1988328ae552a72a96ac4f667d29c0462234ba
5
5
  SHA512:
6
- metadata.gz: 7e58a46313868f955ce7f48303bc2baa726d4f4a9972326fc84cc2eaf6da9eaaad270549986151739e8a10ce2ba39744f3da1ae0dfbbdfbe6e679fa26eada1da
7
- data.tar.gz: b03af25051e7aa00d8f96c32531e024f0e55d6d288c3f0af8f69065086350518a4d5a524c6354f02a2c3ed9b770a4554b071edd910d19a8e4d4220ea3fcbbafb
6
+ metadata.gz: 853a83ae347321c14cb1158f7c5fea7ac57d4ba766308311c596b30b34be347d5a8b97bd29a885f6a0fb07091a741884a4f5a1b6d64a77889dfdba713dc3b5a1
7
+ data.tar.gz: c109355bbb872dbb92259dd4770bf013430c4e5f78dca6bf7d0d08289799c0b681a07deea6fbae1fad6ab5b2f8b1571d045bb46843738bc816bcfa32deacc6b7
@@ -1,3 +1,3 @@
1
1
  module Trackler
2
- VERSION = "2.0.3.2"
2
+ VERSION = "2.0.3.3"
3
3
  end
data/tracks/c/config.json CHANGED
@@ -196,6 +196,16 @@
196
196
  "text formatting",
197
197
  "memory management"
198
198
  ]
199
+ }, {
200
+ "difficulty": 2,
201
+ "slug": "robot-simulator",
202
+ "topics": [
203
+ "strings",
204
+ "control-flow (if-statements)",
205
+ "structs",
206
+ "variable argument lists",
207
+ "pointers"
208
+ ]
199
209
  }],
200
210
  "deprecated": [
201
211
 
@@ -0,0 +1,16 @@
1
+ CFLAGS = -std=c99
2
+ CFLAGS += -Wall
3
+ CFLAGS += -Wextra
4
+ CFLAGS += -pedantic
5
+ CFLAGS += -Werror
6
+
7
+
8
+ test: tests.out
9
+ @./tests.out
10
+
11
+ clean:
12
+ rm -f *.o *.out
13
+
14
+ tests.out: test/test_robot_simulator.c src/robot_simulator.c src/robot_simulator.h
15
+ @echo Compiling $@
16
+ @cc $(CFLAGS) src/robot_simulator.c test/vendor/unity.c test/test_robot_simulator.c -o tests.out
@@ -0,0 +1,74 @@
1
+ #include <string.h>
2
+ #include "robot_simulator.h"
3
+
4
+ RobotGridStatus_t robot_init(void)
5
+ {
6
+ return (robot_init_with_position
7
+ (Default_Bearing, Default_X_Coordinate, Default_Y_Coordinate));
8
+ }
9
+
10
+ RobotGridStatus_t robot_init_with_position(int bearing, int x, int y)
11
+ {
12
+ RobotGridStatus_t robot = { bearing, {x, y} };
13
+
14
+ if ((bearing < Heading_North) || (bearing >= Heading_Max)) {
15
+ robot.bearing = Default_Bearing;
16
+ }
17
+ return robot;
18
+ }
19
+
20
+ void robot_turn_right(RobotGridStatus_t * robot)
21
+ {
22
+ robot->bearing = (robot->bearing + 1) % Heading_Max;
23
+ }
24
+
25
+ void robot_turn_left(RobotGridStatus_t * robot)
26
+ {
27
+ robot->bearing = ((robot->bearing - 1) + Heading_Max) % Heading_Max;
28
+ }
29
+
30
+ void robot_advance(RobotGridStatus_t * robot)
31
+ {
32
+ switch (robot->bearing) {
33
+ case Heading_North:
34
+ robot->grid.y_position++;
35
+ break;
36
+
37
+ case Heading_East:
38
+ robot->grid.x_position++;
39
+ break;
40
+
41
+ case Heading_South:
42
+ robot->grid.y_position--;
43
+ break;
44
+
45
+ case Heading_West:
46
+ robot->grid.x_position--;
47
+ break;
48
+
49
+ default:
50
+ break;
51
+ }
52
+ }
53
+
54
+ void robot_simulator(RobotGridStatus_t * robot, const char *commands)
55
+ {
56
+ for (unsigned long index = 0; index < strlen(commands); index++) {
57
+ switch (commands[index]) {
58
+ case Command_Left:
59
+ robot_turn_left(robot);
60
+ break;
61
+
62
+ case Command_Right:
63
+ robot_turn_right(robot);
64
+ break;
65
+
66
+ case Command_Advance:
67
+ robot_advance(robot);
68
+ break;
69
+
70
+ default:
71
+ break;
72
+ }
73
+ }
74
+ }
@@ -0,0 +1,41 @@
1
+ #ifndef _ROBOT_SIMULATOR_H
2
+ #define _ROBOT_SIMULATOR_H
3
+
4
+ typedef enum {
5
+ Heading_North = 0,
6
+ Heading_East,
7
+ Heading_South,
8
+ Heading_West,
9
+ Heading_Max
10
+ } Bearing_t;
11
+
12
+ enum {
13
+ Default_Bearing = Heading_North,
14
+ Default_X_Coordinate = 0,
15
+ Default_Y_Coordinate = 0,
16
+ };
17
+
18
+ enum {
19
+ Command_Left = 'L',
20
+ Command_Right = 'R',
21
+ Command_Advance = 'A'
22
+ };
23
+
24
+ typedef struct RobotCoordinates {
25
+ int x_position;
26
+ int y_position;
27
+ } RobotCoordinates_t;
28
+
29
+ typedef struct RobotGridStatus {
30
+ Bearing_t bearing;
31
+ RobotCoordinates_t grid;
32
+ } RobotGridStatus_t;
33
+
34
+ RobotGridStatus_t robot_init(void);
35
+ RobotGridStatus_t robot_init_with_position(int bearing, int x, int y);
36
+ void robot_turn_right(RobotGridStatus_t * robot);
37
+ void robot_turn_left(RobotGridStatus_t * robot);
38
+ void robot_advance(RobotGridStatus_t * robot);
39
+ void robot_simulator(RobotGridStatus_t * robot, const char *commands);
40
+
41
+ #endif
@@ -0,0 +1,165 @@
1
+ #include "../src/robot_simulator.h"
2
+ #include "vendor/unity.h"
3
+
4
+ // Test Helper Function
5
+ void confirm_position(RobotGridStatus_t * expected, RobotGridStatus_t * actual)
6
+ {
7
+ TEST_ASSERT_EQUAL(expected->bearing, actual->bearing);
8
+ TEST_ASSERT_EQUAL(expected->grid.x_position, actual->grid.x_position);
9
+ TEST_ASSERT_EQUAL(expected->grid.y_position, actual->grid.y_position);
10
+ }
11
+
12
+ // Tests...
13
+ void test_init(void)
14
+ {
15
+ RobotGridStatus_t expected =
16
+ { Default_Bearing, {Default_X_Coordinate, Default_Y_Coordinate} };
17
+ RobotGridStatus_t actual = robot_init();
18
+
19
+ confirm_position(&expected, &actual);
20
+ }
21
+
22
+ void test_invalid_initial_heading(void)
23
+ {
24
+ RobotGridStatus_t expected =
25
+ { Default_Bearing, {Default_X_Coordinate, Default_Y_Coordinate} };
26
+ RobotGridStatus_t actual =
27
+ robot_init_with_position(99, Default_X_Coordinate, Default_Y_Coordinate);
28
+
29
+ confirm_position(&expected, &actual);
30
+ }
31
+
32
+ void test_init_with_negative_positions(void)
33
+ {
34
+ RobotGridStatus_t expected = { Heading_South, {-1, -1} };
35
+ RobotGridStatus_t actual = robot_init_with_position(Heading_South, -1, -1);
36
+
37
+ confirm_position(&expected, &actual);
38
+ }
39
+
40
+ void test_turn_right(void)
41
+ {
42
+ RobotGridStatus_t expected = { Heading_East, {0, 0} };
43
+ RobotGridStatus_t actual = robot_init();
44
+
45
+ robot_turn_right(&actual);
46
+ confirm_position(&expected, &actual);
47
+
48
+ expected.bearing = Heading_South;
49
+ robot_turn_right(&actual);
50
+ confirm_position(&expected, &actual);
51
+
52
+ expected.bearing = Heading_West;
53
+ robot_turn_right(&actual);
54
+ confirm_position(&expected, &actual);
55
+
56
+ expected.bearing = Heading_North;
57
+ robot_turn_right(&actual);
58
+ confirm_position(&expected, &actual);
59
+ }
60
+
61
+ void test_turn_left(void)
62
+ {
63
+ RobotGridStatus_t expected = { Heading_West, {0, 0} };
64
+ RobotGridStatus_t actual = robot_init();
65
+
66
+ robot_turn_left(&actual);
67
+ confirm_position(&expected, &actual);
68
+
69
+ expected.bearing = Heading_South;
70
+ robot_turn_left(&actual);
71
+ confirm_position(&expected, &actual);
72
+
73
+ expected.bearing = Heading_East;
74
+ robot_turn_left(&actual);
75
+ confirm_position(&expected, &actual);
76
+
77
+ expected.bearing = Heading_North;
78
+ robot_turn_left(&actual);
79
+ confirm_position(&expected, &actual);
80
+ }
81
+
82
+ void test_advance_positive_north(void)
83
+ {
84
+ RobotGridStatus_t expected = { Heading_North, {0, 1} };
85
+ RobotGridStatus_t actual = robot_init();
86
+
87
+ robot_advance(&actual);
88
+ confirm_position(&expected, &actual);
89
+ }
90
+
91
+ void test_advance_positive_east(void)
92
+ {
93
+ RobotGridStatus_t expected = { Heading_East, {1, 0} };
94
+ RobotGridStatus_t actual = robot_init_with_position(Heading_East, 0, 0);
95
+
96
+ robot_advance(&actual);
97
+ confirm_position(&expected, &actual);
98
+ }
99
+
100
+ void test_advance_negative_south(void)
101
+ {
102
+ RobotGridStatus_t expected = { Heading_South, {0, -1} };
103
+ RobotGridStatus_t actual = robot_init_with_position(Heading_South, 0, 0);
104
+
105
+ robot_advance(&actual);
106
+ confirm_position(&expected, &actual);
107
+ }
108
+
109
+ void test_advance_negative_west(void)
110
+ {
111
+ RobotGridStatus_t expected = { Heading_West, {-1, 0} };
112
+ RobotGridStatus_t actual = robot_init_with_position(Heading_West, 0, 0);
113
+
114
+ robot_advance(&actual);
115
+ confirm_position(&expected, &actual);
116
+ }
117
+
118
+ void test_simulate_move_west_and_north(void)
119
+ {
120
+ RobotGridStatus_t expected = { Heading_West, {-4, 1} };
121
+ RobotGridStatus_t actual = robot_init();
122
+
123
+ robot_simulator(&actual, "LAAARALA");
124
+ confirm_position(&expected, &actual);
125
+ }
126
+
127
+ void test_simulate_move_west_and_south(void)
128
+ {
129
+ RobotGridStatus_t expected = { Heading_South, {-3, -8} };
130
+ RobotGridStatus_t actual = robot_init_with_position(Heading_East, 2, -7);
131
+
132
+ robot_simulator(&actual, "RRAAAAALA");
133
+ confirm_position(&expected, &actual);
134
+ }
135
+
136
+ void test_simulate_move_east_and_north(void)
137
+ {
138
+ RobotGridStatus_t expected = { Heading_North, {11, 5} };
139
+ RobotGridStatus_t actual = robot_init_with_position(Heading_South, 8, 4);
140
+
141
+ robot_simulator(&actual, "LAAARRRALLLL");
142
+ confirm_position(&expected, &actual);
143
+ }
144
+
145
+ int main(void)
146
+ {
147
+ UnityBegin("test/test_word_count.c");
148
+
149
+ RUN_TEST(test_init);
150
+ RUN_TEST(test_invalid_initial_heading);
151
+ RUN_TEST(test_init_with_negative_positions);
152
+ RUN_TEST(test_turn_right);
153
+ RUN_TEST(test_turn_left);
154
+ RUN_TEST(test_advance_positive_north);
155
+ RUN_TEST(test_advance_positive_east);
156
+ RUN_TEST(test_advance_negative_south);
157
+ RUN_TEST(test_advance_negative_west);
158
+ RUN_TEST(test_simulate_move_west_and_north);
159
+ RUN_TEST(test_simulate_move_west_and_south);
160
+ RUN_TEST(test_simulate_move_east_and_north);
161
+
162
+ UnityEnd();
163
+
164
+ return 0;
165
+ }
@@ -0,0 +1,1300 @@
1
+ /* =========================================================================
2
+ Unity Project - A Test Framework for C
3
+ Copyright (c) 2007-14 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
+ #include <stddef.h>
9
+
10
+ #define UNITY_FAIL_AND_BAIL { Unity.CurrentTestFailed = 1; longjmp(Unity.AbortFrame, 1); }
11
+ #define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; longjmp(Unity.AbortFrame, 1); }
12
+ /// return prematurely if we are already in failure or ignore state
13
+ #define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} }
14
+ #define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\n'); }
15
+
16
+ struct _Unity Unity;
17
+
18
+ const char UnityStrOk[] = "OK";
19
+ const char UnityStrPass[] = "PASS";
20
+ const char UnityStrFail[] = "FAIL";
21
+ const char UnityStrIgnore[] = "IGNORE";
22
+ const char UnityStrNull[] = "NULL";
23
+ const char UnityStrSpacer[] = ". ";
24
+ const char UnityStrExpected[] = " Expected ";
25
+ const char UnityStrWas[] = " Was ";
26
+ const char UnityStrTo[] = " To ";
27
+ const char UnityStrElement[] = " Element ";
28
+ const char UnityStrByte[] = " Byte ";
29
+ const char UnityStrMemory[] = " Memory Mismatch.";
30
+ const char UnityStrDelta[] = " Values Not Within Delta ";
31
+ const char UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless.";
32
+ const char UnityStrNullPointerForExpected[] = " Expected pointer to be NULL";
33
+ const char UnityStrNullPointerForActual[] = " Actual pointer was NULL";
34
+ const char UnityStrNot[] = "Not ";
35
+ const char UnityStrInf[] = "Infinity";
36
+ const char UnityStrNegInf[] = "Negative Infinity";
37
+ const char UnityStrNaN[] = "NaN";
38
+ const char UnityStrDet[] = "Determinate";
39
+ const char UnityStrErrFloat[] = "Unity Floating Point Disabled";
40
+ const char UnityStrErrDouble[] = "Unity Double Precision Disabled";
41
+ const char UnityStrErr64[] = "Unity 64-bit Support Disabled";
42
+ const char UnityStrBreaker[] = "-----------------------";
43
+ const char UnityStrResultsTests[] = " Tests ";
44
+ const char UnityStrResultsFailures[] = " Failures ";
45
+ const char UnityStrResultsIgnored[] = " Ignored ";
46
+
47
+ #ifndef UNITY_EXCLUDE_FLOAT
48
+ // Dividing by these constants produces +/- infinity.
49
+ // The rationale is given in UnityAssertFloatIsInf's body.
50
+ static const _UF f_zero = 0.0f;
51
+ #ifndef UNITY_EXCLUDE_DOUBLE
52
+ static const _UD d_zero = 0.0;
53
+ #endif
54
+ #endif
55
+
56
+ // compiler-generic print formatting masks
57
+ const _U_UINT UnitySizeMask[] =
58
+ {
59
+ 255u, // 0xFF
60
+ 65535u, // 0xFFFF
61
+ 65535u,
62
+ 4294967295u, // 0xFFFFFFFF
63
+ 4294967295u,
64
+ 4294967295u,
65
+ 4294967295u
66
+ #ifdef UNITY_SUPPORT_64
67
+ ,0xFFFFFFFFFFFFFFFF
68
+ #endif
69
+ };
70
+
71
+ void UnityPrintFail(void);
72
+ void UnityPrintOk(void);
73
+
74
+ //-----------------------------------------------
75
+ // Pretty Printers & Test Result Output Handlers
76
+ //-----------------------------------------------
77
+
78
+ void UnityPrint(const char* string)
79
+ {
80
+ const char* pch = string;
81
+
82
+ if (pch != NULL)
83
+ {
84
+ while (*pch)
85
+ {
86
+ // printable characters plus CR & LF are printed
87
+ if ((*pch <= 126) && (*pch >= 32))
88
+ {
89
+ UNITY_OUTPUT_CHAR(*pch);
90
+ }
91
+ //write escaped carriage returns
92
+ else if (*pch == 13)
93
+ {
94
+ UNITY_OUTPUT_CHAR('\\');
95
+ UNITY_OUTPUT_CHAR('r');
96
+ }
97
+ //write escaped line feeds
98
+ else if (*pch == 10)
99
+ {
100
+ UNITY_OUTPUT_CHAR('\\');
101
+ UNITY_OUTPUT_CHAR('n');
102
+ }
103
+ // unprintable characters are shown as codes
104
+ else
105
+ {
106
+ UNITY_OUTPUT_CHAR('\\');
107
+ UnityPrintNumberHex((_U_UINT)*pch, 2);
108
+ }
109
+ pch++;
110
+ }
111
+ }
112
+ }
113
+
114
+ void UnityPrintLen(const char* string, const _UU32 length);
115
+ void UnityPrintLen(const char* string, const _UU32 length)
116
+ {
117
+ const char* pch = string;
118
+
119
+ if (pch != NULL)
120
+ {
121
+ while (*pch && (_UU32)(pch - string) < length)
122
+ {
123
+ // printable characters plus CR & LF are printed
124
+ if ((*pch <= 126) && (*pch >= 32))
125
+ {
126
+ UNITY_OUTPUT_CHAR(*pch);
127
+ }
128
+ //write escaped carriage returns
129
+ else if (*pch == 13)
130
+ {
131
+ UNITY_OUTPUT_CHAR('\\');
132
+ UNITY_OUTPUT_CHAR('r');
133
+ }
134
+ //write escaped line feeds
135
+ else if (*pch == 10)
136
+ {
137
+ UNITY_OUTPUT_CHAR('\\');
138
+ UNITY_OUTPUT_CHAR('n');
139
+ }
140
+ // unprintable characters are shown as codes
141
+ else
142
+ {
143
+ UNITY_OUTPUT_CHAR('\\');
144
+ UnityPrintNumberHex((_U_UINT)*pch, 2);
145
+ }
146
+ pch++;
147
+ }
148
+ }
149
+ }
150
+
151
+ //-----------------------------------------------
152
+ void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style)
153
+ {
154
+ if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
155
+ {
156
+ UnityPrintNumber(number);
157
+ }
158
+ else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
159
+ {
160
+ UnityPrintNumberUnsigned( (_U_UINT)number & UnitySizeMask[((_U_UINT)style & (_U_UINT)0x0F) - 1] );
161
+ }
162
+ else
163
+ {
164
+ UnityPrintNumberHex((_U_UINT)number, (char)((style & 0x000F) << 1));
165
+ }
166
+ }
167
+
168
+ //-----------------------------------------------
169
+ /// basically do an itoa using as little ram as possible
170
+ void UnityPrintNumber(const _U_SINT number_to_print)
171
+ {
172
+ _U_SINT divisor = 1;
173
+ _U_SINT next_divisor;
174
+ _U_UINT number;
175
+
176
+ if (number_to_print == (1l << (UNITY_LONG_WIDTH-1)))
177
+ {
178
+ //The largest representable negative number
179
+ UNITY_OUTPUT_CHAR('-');
180
+ number = (1ul << (UNITY_LONG_WIDTH-1));
181
+ }
182
+ else if (number_to_print < 0)
183
+ {
184
+ //Some other negative number
185
+ UNITY_OUTPUT_CHAR('-');
186
+ number = (_U_UINT)(-number_to_print);
187
+ }
188
+ else
189
+ {
190
+ //Positive number
191
+ number = (_U_UINT)number_to_print;
192
+ }
193
+
194
+ // figure out initial divisor
195
+ while (number / divisor > 9)
196
+ {
197
+ next_divisor = divisor * 10;
198
+ if (next_divisor > divisor)
199
+ divisor = next_divisor;
200
+ else
201
+ break;
202
+ }
203
+
204
+ // now mod and print, then divide divisor
205
+ do
206
+ {
207
+ UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
208
+ divisor /= 10;
209
+ }
210
+ while (divisor > 0);
211
+ }
212
+
213
+ //-----------------------------------------------
214
+ /// basically do an itoa using as little ram as possible
215
+ void UnityPrintNumberUnsigned(const _U_UINT number)
216
+ {
217
+ _U_UINT divisor = 1;
218
+ _U_UINT next_divisor;
219
+
220
+ // figure out initial divisor
221
+ while (number / divisor > 9)
222
+ {
223
+ next_divisor = divisor * 10;
224
+ if (next_divisor > divisor)
225
+ divisor = next_divisor;
226
+ else
227
+ break;
228
+ }
229
+
230
+ // now mod and print, then divide divisor
231
+ do
232
+ {
233
+ UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
234
+ divisor /= 10;
235
+ }
236
+ while (divisor > 0);
237
+ }
238
+
239
+ //-----------------------------------------------
240
+ void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print)
241
+ {
242
+ _U_UINT nibble;
243
+ char nibbles = nibbles_to_print;
244
+ UNITY_OUTPUT_CHAR('0');
245
+ UNITY_OUTPUT_CHAR('x');
246
+
247
+ while (nibbles > 0)
248
+ {
249
+ nibble = (number >> (--nibbles << 2)) & 0x0000000F;
250
+ if (nibble <= 9)
251
+ {
252
+ UNITY_OUTPUT_CHAR((char)('0' + nibble));
253
+ }
254
+ else
255
+ {
256
+ UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
257
+ }
258
+ }
259
+ }
260
+
261
+ //-----------------------------------------------
262
+ void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
263
+ {
264
+ _U_UINT current_bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1);
265
+ _US32 i;
266
+
267
+ for (i = 0; i < UNITY_INT_WIDTH; i++)
268
+ {
269
+ if (current_bit & mask)
270
+ {
271
+ if (current_bit & number)
272
+ {
273
+ UNITY_OUTPUT_CHAR('1');
274
+ }
275
+ else
276
+ {
277
+ UNITY_OUTPUT_CHAR('0');
278
+ }
279
+ }
280
+ else
281
+ {
282
+ UNITY_OUTPUT_CHAR('X');
283
+ }
284
+ current_bit = current_bit >> 1;
285
+ }
286
+ }
287
+
288
+ //-----------------------------------------------
289
+ #ifdef UNITY_FLOAT_VERBOSE
290
+ #include <string.h>
291
+ void UnityPrintFloat(_UF number)
292
+ {
293
+ char TempBuffer[32];
294
+ sprintf(TempBuffer, "%.6f", number);
295
+ UnityPrint(TempBuffer);
296
+ }
297
+ #endif
298
+
299
+ //-----------------------------------------------
300
+
301
+ void UnityPrintFail(void);
302
+ void UnityPrintFail(void)
303
+ {
304
+ UnityPrint(UnityStrFail);
305
+ }
306
+
307
+ void UnityPrintOk(void);
308
+ void UnityPrintOk(void)
309
+ {
310
+ UnityPrint(UnityStrOk);
311
+ }
312
+
313
+ //-----------------------------------------------
314
+ static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line);
315
+ static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
316
+ {
317
+ #ifndef UNITY_FIXTURES
318
+ UnityPrint(file);
319
+ UNITY_OUTPUT_CHAR(':');
320
+ UnityPrintNumber((_U_SINT)line);
321
+ UNITY_OUTPUT_CHAR(':');
322
+ UnityPrint(Unity.CurrentTestName);
323
+ UNITY_OUTPUT_CHAR(':');
324
+ #else
325
+ UNITY_UNUSED(file);
326
+ UNITY_UNUSED(line);
327
+ #endif
328
+ }
329
+
330
+ //-----------------------------------------------
331
+ static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line);
332
+ static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line)
333
+ {
334
+ #ifndef UNITY_FIXTURES
335
+ UnityTestResultsBegin(Unity.TestFile, line);
336
+ #else
337
+ UNITY_UNUSED(line);
338
+ #endif
339
+ UnityPrint(UnityStrFail);
340
+ UNITY_OUTPUT_CHAR(':');
341
+ }
342
+
343
+ //-----------------------------------------------
344
+ void UnityConcludeTest(void)
345
+ {
346
+ if (Unity.CurrentTestIgnored)
347
+ {
348
+ Unity.TestIgnores++;
349
+ }
350
+ else if (!Unity.CurrentTestFailed)
351
+ {
352
+ UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
353
+ UnityPrint(UnityStrPass);
354
+ }
355
+ else
356
+ {
357
+ Unity.TestFailures++;
358
+ }
359
+
360
+ Unity.CurrentTestFailed = 0;
361
+ Unity.CurrentTestIgnored = 0;
362
+ UNITY_PRINT_EOL;
363
+ }
364
+
365
+ //-----------------------------------------------
366
+ static void UnityAddMsgIfSpecified(const char* msg);
367
+ static void UnityAddMsgIfSpecified(const char* msg)
368
+ {
369
+ if (msg)
370
+ {
371
+ UnityPrint(UnityStrSpacer);
372
+ UnityPrint(msg);
373
+ }
374
+ }
375
+
376
+ //-----------------------------------------------
377
+ static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual);
378
+ static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
379
+ {
380
+ UnityPrint(UnityStrExpected);
381
+ if (expected != NULL)
382
+ {
383
+ UNITY_OUTPUT_CHAR('\'');
384
+ UnityPrint(expected);
385
+ UNITY_OUTPUT_CHAR('\'');
386
+ }
387
+ else
388
+ {
389
+ UnityPrint(UnityStrNull);
390
+ }
391
+ UnityPrint(UnityStrWas);
392
+ if (actual != NULL)
393
+ {
394
+ UNITY_OUTPUT_CHAR('\'');
395
+ UnityPrint(actual);
396
+ UNITY_OUTPUT_CHAR('\'');
397
+ }
398
+ else
399
+ {
400
+ UnityPrint(UnityStrNull);
401
+ }
402
+ }
403
+
404
+ //-----------------------------------------------
405
+ static void UnityPrintExpectedAndActualStringsLen(const char* expected, const char* actual, const _UU32 length)
406
+ {
407
+ UnityPrint(UnityStrExpected);
408
+ if (expected != NULL)
409
+ {
410
+ UNITY_OUTPUT_CHAR('\'');
411
+ UnityPrintLen(expected, length);
412
+ UNITY_OUTPUT_CHAR('\'');
413
+ }
414
+ else
415
+ {
416
+ UnityPrint(UnityStrNull);
417
+ }
418
+ UnityPrint(UnityStrWas);
419
+ if (actual != NULL)
420
+ {
421
+ UNITY_OUTPUT_CHAR('\'');
422
+ UnityPrintLen(actual, length);
423
+ UNITY_OUTPUT_CHAR('\'');
424
+ }
425
+ else
426
+ {
427
+ UnityPrint(UnityStrNull);
428
+ }
429
+ }
430
+
431
+
432
+
433
+ //-----------------------------------------------
434
+ // Assertion & Control Helpers
435
+ //-----------------------------------------------
436
+
437
+ static int UnityCheckArraysForNull(UNITY_PTR_ATTRIBUTE const void* expected, UNITY_PTR_ATTRIBUTE const void* actual, const UNITY_LINE_TYPE lineNumber, const char* msg)
438
+ {
439
+ //return true if they are both NULL
440
+ if ((expected == NULL) && (actual == NULL))
441
+ return 1;
442
+
443
+ //throw error if just expected is NULL
444
+ if (expected == NULL)
445
+ {
446
+ UnityTestResultsFailBegin(lineNumber);
447
+ UnityPrint(UnityStrNullPointerForExpected);
448
+ UnityAddMsgIfSpecified(msg);
449
+ UNITY_FAIL_AND_BAIL;
450
+ }
451
+
452
+ //throw error if just actual is NULL
453
+ if (actual == NULL)
454
+ {
455
+ UnityTestResultsFailBegin(lineNumber);
456
+ UnityPrint(UnityStrNullPointerForActual);
457
+ UnityAddMsgIfSpecified(msg);
458
+ UNITY_FAIL_AND_BAIL;
459
+ }
460
+
461
+ //return false if neither is NULL
462
+ return 0;
463
+ }
464
+
465
+ //-----------------------------------------------
466
+ // Assertion Functions
467
+ //-----------------------------------------------
468
+
469
+ void UnityAssertBits(const _U_SINT mask,
470
+ const _U_SINT expected,
471
+ const _U_SINT actual,
472
+ const char* msg,
473
+ const UNITY_LINE_TYPE lineNumber)
474
+ {
475
+ UNITY_SKIP_EXECUTION;
476
+
477
+ if ((mask & expected) != (mask & actual))
478
+ {
479
+ UnityTestResultsFailBegin(lineNumber);
480
+ UnityPrint(UnityStrExpected);
481
+ UnityPrintMask((_U_UINT)mask, (_U_UINT)expected);
482
+ UnityPrint(UnityStrWas);
483
+ UnityPrintMask((_U_UINT)mask, (_U_UINT)actual);
484
+ UnityAddMsgIfSpecified(msg);
485
+ UNITY_FAIL_AND_BAIL;
486
+ }
487
+ }
488
+
489
+ //-----------------------------------------------
490
+ void UnityAssertEqualNumber(const _U_SINT expected,
491
+ const _U_SINT actual,
492
+ const char* msg,
493
+ const UNITY_LINE_TYPE lineNumber,
494
+ const UNITY_DISPLAY_STYLE_T style)
495
+ {
496
+ UNITY_SKIP_EXECUTION;
497
+
498
+ if (expected != actual)
499
+ {
500
+ UnityTestResultsFailBegin(lineNumber);
501
+ UnityPrint(UnityStrExpected);
502
+ UnityPrintNumberByStyle(expected, style);
503
+ UnityPrint(UnityStrWas);
504
+ UnityPrintNumberByStyle(actual, style);
505
+ UnityAddMsgIfSpecified(msg);
506
+ UNITY_FAIL_AND_BAIL;
507
+ }
508
+ }
509
+
510
+ //-----------------------------------------------
511
+ void UnityAssertEqualIntArray(UNITY_PTR_ATTRIBUTE const void* expected,
512
+ UNITY_PTR_ATTRIBUTE const void* actual,
513
+ const _UU32 num_elements,
514
+ const char* msg,
515
+ const UNITY_LINE_TYPE lineNumber,
516
+ const UNITY_DISPLAY_STYLE_T style)
517
+ {
518
+ _UU32 elements = num_elements;
519
+ UNITY_PTR_ATTRIBUTE const void* ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)expected;
520
+ UNITY_PTR_ATTRIBUTE const void* ptr_act = (UNITY_PTR_ATTRIBUTE const void*)actual;
521
+
522
+ UNITY_SKIP_EXECUTION;
523
+
524
+ if (elements == 0)
525
+ {
526
+ UnityTestResultsFailBegin(lineNumber);
527
+ UnityPrint(UnityStrPointless);
528
+ UnityAddMsgIfSpecified(msg);
529
+ UNITY_FAIL_AND_BAIL;
530
+ }
531
+
532
+ if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE const void*)expected, (UNITY_PTR_ATTRIBUTE const void*)actual, lineNumber, msg) == 1)
533
+ return;
534
+
535
+ // If style is UNITY_DISPLAY_STYLE_INT, we'll fall into the default case rather than the INT16 or INT32 (etc) case
536
+ // as UNITY_DISPLAY_STYLE_INT includes a flag for UNITY_DISPLAY_RANGE_AUTO, which the width-specific
537
+ // variants do not. Therefore remove this flag.
538
+ switch(style & (UNITY_DISPLAY_STYLE_T)(~UNITY_DISPLAY_RANGE_AUTO))
539
+ {
540
+ case UNITY_DISPLAY_STYLE_HEX8:
541
+ case UNITY_DISPLAY_STYLE_INT8:
542
+ case UNITY_DISPLAY_STYLE_UINT8:
543
+ while (elements--)
544
+ {
545
+ if (*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act)
546
+ {
547
+ UnityTestResultsFailBegin(lineNumber);
548
+ UnityPrint(UnityStrElement);
549
+ UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
550
+ UnityPrint(UnityStrExpected);
551
+ UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp, style);
552
+ UnityPrint(UnityStrWas);
553
+ UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act, style);
554
+ UnityAddMsgIfSpecified(msg);
555
+ UNITY_FAIL_AND_BAIL;
556
+ }
557
+ ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 1);
558
+ ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 1);
559
+ }
560
+ break;
561
+ case UNITY_DISPLAY_STYLE_HEX16:
562
+ case UNITY_DISPLAY_STYLE_INT16:
563
+ case UNITY_DISPLAY_STYLE_UINT16:
564
+ while (elements--)
565
+ {
566
+ if (*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act)
567
+ {
568
+ UnityTestResultsFailBegin(lineNumber);
569
+ UnityPrint(UnityStrElement);
570
+ UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
571
+ UnityPrint(UnityStrExpected);
572
+ UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp, style);
573
+ UnityPrint(UnityStrWas);
574
+ UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act, style);
575
+ UnityAddMsgIfSpecified(msg);
576
+ UNITY_FAIL_AND_BAIL;
577
+ }
578
+ ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 2);
579
+ ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 2);
580
+ }
581
+ break;
582
+ #ifdef UNITY_SUPPORT_64
583
+ case UNITY_DISPLAY_STYLE_HEX64:
584
+ case UNITY_DISPLAY_STYLE_INT64:
585
+ case UNITY_DISPLAY_STYLE_UINT64:
586
+ while (elements--)
587
+ {
588
+ if (*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act)
589
+ {
590
+ UnityTestResultsFailBegin(lineNumber);
591
+ UnityPrint(UnityStrElement);
592
+ UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
593
+ UnityPrint(UnityStrExpected);
594
+ UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp, style);
595
+ UnityPrint(UnityStrWas);
596
+ UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act, style);
597
+ UnityAddMsgIfSpecified(msg);
598
+ UNITY_FAIL_AND_BAIL;
599
+ }
600
+ ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 8);
601
+ ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 8);
602
+ }
603
+ break;
604
+ #endif
605
+ default:
606
+ while (elements--)
607
+ {
608
+ if (*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act)
609
+ {
610
+ UnityTestResultsFailBegin(lineNumber);
611
+ UnityPrint(UnityStrElement);
612
+ UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
613
+ UnityPrint(UnityStrExpected);
614
+ UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp, style);
615
+ UnityPrint(UnityStrWas);
616
+ UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act, style);
617
+ UnityAddMsgIfSpecified(msg);
618
+ UNITY_FAIL_AND_BAIL;
619
+ }
620
+ ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 4);
621
+ ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 4);
622
+ }
623
+ break;
624
+ }
625
+ }
626
+
627
+ //-----------------------------------------------
628
+ #ifndef UNITY_EXCLUDE_FLOAT
629
+ void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
630
+ UNITY_PTR_ATTRIBUTE const _UF* actual,
631
+ const _UU32 num_elements,
632
+ const char* msg,
633
+ const UNITY_LINE_TYPE lineNumber)
634
+ {
635
+ _UU32 elements = num_elements;
636
+ UNITY_PTR_ATTRIBUTE const _UF* ptr_expected = expected;
637
+ UNITY_PTR_ATTRIBUTE const _UF* ptr_actual = actual;
638
+ _UF diff, tol;
639
+
640
+ UNITY_SKIP_EXECUTION;
641
+
642
+ if (elements == 0)
643
+ {
644
+ UnityTestResultsFailBegin(lineNumber);
645
+ UnityPrint(UnityStrPointless);
646
+ UnityAddMsgIfSpecified(msg);
647
+ UNITY_FAIL_AND_BAIL;
648
+ }
649
+
650
+ if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE const void*)expected, (UNITY_PTR_ATTRIBUTE const void*)actual, lineNumber, msg) == 1)
651
+ return;
652
+
653
+ while (elements--)
654
+ {
655
+ diff = *ptr_expected - *ptr_actual;
656
+ if (diff < 0.0f)
657
+ diff = 0.0f - diff;
658
+ tol = UNITY_FLOAT_PRECISION * *ptr_expected;
659
+ if (tol < 0.0f)
660
+ tol = 0.0f - tol;
661
+
662
+ //This first part of this condition will catch any NaN or Infinite values
663
+ if ((diff * 0.0f != 0.0f) || (diff > tol))
664
+ {
665
+ UnityTestResultsFailBegin(lineNumber);
666
+ UnityPrint(UnityStrElement);
667
+ UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
668
+ #ifdef UNITY_FLOAT_VERBOSE
669
+ UnityPrint(UnityStrExpected);
670
+ UnityPrintFloat(*ptr_expected);
671
+ UnityPrint(UnityStrWas);
672
+ UnityPrintFloat(*ptr_actual);
673
+ #else
674
+ UnityPrint(UnityStrDelta);
675
+ #endif
676
+ UnityAddMsgIfSpecified(msg);
677
+ UNITY_FAIL_AND_BAIL;
678
+ }
679
+ ptr_expected++;
680
+ ptr_actual++;
681
+ }
682
+ }
683
+
684
+ //-----------------------------------------------
685
+ void UnityAssertFloatsWithin(const _UF delta,
686
+ const _UF expected,
687
+ const _UF actual,
688
+ const char* msg,
689
+ const UNITY_LINE_TYPE lineNumber)
690
+ {
691
+ _UF diff = actual - expected;
692
+ _UF pos_delta = delta;
693
+
694
+ UNITY_SKIP_EXECUTION;
695
+
696
+ if (diff < 0.0f)
697
+ {
698
+ diff = 0.0f - diff;
699
+ }
700
+ if (pos_delta < 0.0f)
701
+ {
702
+ pos_delta = 0.0f - pos_delta;
703
+ }
704
+
705
+ //This first part of this condition will catch any NaN or Infinite values
706
+ if ((diff * 0.0f != 0.0f) || (pos_delta < diff))
707
+ {
708
+ UnityTestResultsFailBegin(lineNumber);
709
+ #ifdef UNITY_FLOAT_VERBOSE
710
+ UnityPrint(UnityStrExpected);
711
+ UnityPrintFloat(expected);
712
+ UnityPrint(UnityStrWas);
713
+ UnityPrintFloat(actual);
714
+ #else
715
+ UnityPrint(UnityStrDelta);
716
+ #endif
717
+ UnityAddMsgIfSpecified(msg);
718
+ UNITY_FAIL_AND_BAIL;
719
+ }
720
+ }
721
+
722
+ //-----------------------------------------------
723
+ void UnityAssertFloatSpecial(const _UF actual,
724
+ const char* msg,
725
+ const UNITY_LINE_TYPE lineNumber,
726
+ const UNITY_FLOAT_TRAIT_T style)
727
+ {
728
+ const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet };
729
+ _U_SINT should_be_trait = ((_U_SINT)style & 1);
730
+ _U_SINT is_trait = !should_be_trait;
731
+ _U_SINT trait_index = style >> 1;
732
+
733
+ UNITY_SKIP_EXECUTION;
734
+
735
+ switch(style)
736
+ {
737
+ //To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
738
+ //We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise
739
+ case UNITY_FLOAT_IS_INF:
740
+ case UNITY_FLOAT_IS_NOT_INF:
741
+ is_trait = ((1.0f / f_zero) == actual) ? 1 : 0;
742
+ break;
743
+ case UNITY_FLOAT_IS_NEG_INF:
744
+ case UNITY_FLOAT_IS_NOT_NEG_INF:
745
+ is_trait = ((-1.0f / f_zero) == actual) ? 1 : 0;
746
+ break;
747
+
748
+ //NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN.
749
+ case UNITY_FLOAT_IS_NAN:
750
+ case UNITY_FLOAT_IS_NOT_NAN:
751
+ is_trait = (actual == actual) ? 0 : 1;
752
+ break;
753
+
754
+ //A determinate number is non infinite and not NaN. (therefore the opposite of the two above)
755
+ case UNITY_FLOAT_IS_DET:
756
+ case UNITY_FLOAT_IS_NOT_DET:
757
+ if ( (actual != actual) || ((1.0f / f_zero) == actual) || ((-1.0f / f_zero) == actual) )
758
+ is_trait = 0;
759
+ else
760
+ is_trait = 1;
761
+ break;
762
+ default:
763
+ ;
764
+ }
765
+
766
+ if (is_trait != should_be_trait)
767
+ {
768
+ UnityTestResultsFailBegin(lineNumber);
769
+ UnityPrint(UnityStrExpected);
770
+ if (!should_be_trait)
771
+ UnityPrint(UnityStrNot);
772
+ UnityPrint(trait_names[trait_index]);
773
+ UnityPrint(UnityStrWas);
774
+ #ifdef UNITY_FLOAT_VERBOSE
775
+ UnityPrintFloat(actual);
776
+ #else
777
+ if (should_be_trait)
778
+ UnityPrint(UnityStrNot);
779
+ UnityPrint(trait_names[trait_index]);
780
+ #endif
781
+ UnityAddMsgIfSpecified(msg);
782
+ UNITY_FAIL_AND_BAIL;
783
+ }
784
+ }
785
+
786
+ #endif //not UNITY_EXCLUDE_FLOAT
787
+
788
+ //-----------------------------------------------
789
+ #ifndef UNITY_EXCLUDE_DOUBLE
790
+ void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
791
+ UNITY_PTR_ATTRIBUTE const _UD* actual,
792
+ const _UU32 num_elements,
793
+ const char* msg,
794
+ const UNITY_LINE_TYPE lineNumber)
795
+ {
796
+ _UU32 elements = num_elements;
797
+ UNITY_PTR_ATTRIBUTE const _UD* ptr_expected = expected;
798
+ UNITY_PTR_ATTRIBUTE const _UD* ptr_actual = actual;
799
+ _UD diff, tol;
800
+
801
+ UNITY_SKIP_EXECUTION;
802
+
803
+ if (elements == 0)
804
+ {
805
+ UnityTestResultsFailBegin(lineNumber);
806
+ UnityPrint(UnityStrPointless);
807
+ UnityAddMsgIfSpecified(msg);
808
+ UNITY_FAIL_AND_BAIL;
809
+ }
810
+
811
+ if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE void*)expected, (UNITY_PTR_ATTRIBUTE void*)actual, lineNumber, msg) == 1)
812
+ return;
813
+
814
+ while (elements--)
815
+ {
816
+ diff = *ptr_expected - *ptr_actual;
817
+ if (diff < 0.0)
818
+ diff = 0.0 - diff;
819
+ tol = UNITY_DOUBLE_PRECISION * *ptr_expected;
820
+ if (tol < 0.0)
821
+ tol = 0.0 - tol;
822
+
823
+ //This first part of this condition will catch any NaN or Infinite values
824
+ if ((diff * 0.0 != 0.0) || (diff > tol))
825
+ {
826
+ UnityTestResultsFailBegin(lineNumber);
827
+ UnityPrint(UnityStrElement);
828
+ UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
829
+ #ifdef UNITY_DOUBLE_VERBOSE
830
+ UnityPrint(UnityStrExpected);
831
+ UnityPrintFloat((float)(*ptr_expected));
832
+ UnityPrint(UnityStrWas);
833
+ UnityPrintFloat((float)(*ptr_actual));
834
+ #else
835
+ UnityPrint(UnityStrDelta);
836
+ #endif
837
+ UnityAddMsgIfSpecified(msg);
838
+ UNITY_FAIL_AND_BAIL;
839
+ }
840
+ ptr_expected++;
841
+ ptr_actual++;
842
+ }
843
+ }
844
+
845
+ //-----------------------------------------------
846
+ void UnityAssertDoublesWithin(const _UD delta,
847
+ const _UD expected,
848
+ const _UD actual,
849
+ const char* msg,
850
+ const UNITY_LINE_TYPE lineNumber)
851
+ {
852
+ _UD diff = actual - expected;
853
+ _UD pos_delta = delta;
854
+
855
+ UNITY_SKIP_EXECUTION;
856
+
857
+ if (diff < 0.0)
858
+ {
859
+ diff = 0.0 - diff;
860
+ }
861
+ if (pos_delta < 0.0)
862
+ {
863
+ pos_delta = 0.0 - pos_delta;
864
+ }
865
+
866
+ //This first part of this condition will catch any NaN or Infinite values
867
+ if ((diff * 0.0 != 0.0) || (pos_delta < diff))
868
+ {
869
+ UnityTestResultsFailBegin(lineNumber);
870
+ #ifdef UNITY_DOUBLE_VERBOSE
871
+ UnityPrint(UnityStrExpected);
872
+ UnityPrintFloat((float)expected);
873
+ UnityPrint(UnityStrWas);
874
+ UnityPrintFloat((float)actual);
875
+ #else
876
+ UnityPrint(UnityStrDelta);
877
+ #endif
878
+ UnityAddMsgIfSpecified(msg);
879
+ UNITY_FAIL_AND_BAIL;
880
+ }
881
+ }
882
+
883
+ //-----------------------------------------------
884
+
885
+ void UnityAssertDoubleSpecial(const _UD actual,
886
+ const char* msg,
887
+ const UNITY_LINE_TYPE lineNumber,
888
+ const UNITY_FLOAT_TRAIT_T style)
889
+ {
890
+ const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet };
891
+ _U_SINT should_be_trait = ((_U_SINT)style & 1);
892
+ _U_SINT is_trait = !should_be_trait;
893
+ _U_SINT trait_index = style >> 1;
894
+
895
+ UNITY_SKIP_EXECUTION;
896
+
897
+ switch(style)
898
+ {
899
+ //To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
900
+ //We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise
901
+ case UNITY_FLOAT_IS_INF:
902
+ case UNITY_FLOAT_IS_NOT_INF:
903
+ is_trait = ((1.0 / d_zero) == actual) ? 1 : 0;
904
+ break;
905
+ case UNITY_FLOAT_IS_NEG_INF:
906
+ case UNITY_FLOAT_IS_NOT_NEG_INF:
907
+ is_trait = ((-1.0 / d_zero) == actual) ? 1 : 0;
908
+ break;
909
+
910
+ //NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN.
911
+ case UNITY_FLOAT_IS_NAN:
912
+ case UNITY_FLOAT_IS_NOT_NAN:
913
+ is_trait = (actual == actual) ? 0 : 1;
914
+ break;
915
+
916
+ //A determinate number is non infinite and not NaN. (therefore the opposite of the two above)
917
+ case UNITY_FLOAT_IS_DET:
918
+ case UNITY_FLOAT_IS_NOT_DET:
919
+ if ( (actual != actual) || ((1.0 / d_zero) == actual) || ((-1.0 / d_zero) == actual) )
920
+ is_trait = 0;
921
+ else
922
+ is_trait = 1;
923
+ break;
924
+ default:
925
+ ;
926
+ }
927
+
928
+ if (is_trait != should_be_trait)
929
+ {
930
+ UnityTestResultsFailBegin(lineNumber);
931
+ UnityPrint(UnityStrExpected);
932
+ if (!should_be_trait)
933
+ UnityPrint(UnityStrNot);
934
+ UnityPrint(trait_names[trait_index]);
935
+ UnityPrint(UnityStrWas);
936
+ #ifdef UNITY_DOUBLE_VERBOSE
937
+ UnityPrintFloat(actual);
938
+ #else
939
+ if (should_be_trait)
940
+ UnityPrint(UnityStrNot);
941
+ UnityPrint(trait_names[trait_index]);
942
+ #endif
943
+ UnityAddMsgIfSpecified(msg);
944
+ UNITY_FAIL_AND_BAIL;
945
+ }
946
+ }
947
+
948
+
949
+ #endif // not UNITY_EXCLUDE_DOUBLE
950
+
951
+ //-----------------------------------------------
952
+ void UnityAssertNumbersWithin( const _U_SINT delta,
953
+ const _U_SINT expected,
954
+ const _U_SINT actual,
955
+ const char* msg,
956
+ const UNITY_LINE_TYPE lineNumber,
957
+ const UNITY_DISPLAY_STYLE_T style)
958
+ {
959
+ UNITY_SKIP_EXECUTION;
960
+
961
+ if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
962
+ {
963
+ if (actual > expected)
964
+ Unity.CurrentTestFailed = ((actual - expected) > delta);
965
+ else
966
+ Unity.CurrentTestFailed = ((expected - actual) > delta);
967
+ }
968
+ else
969
+ {
970
+ if ((_U_UINT)actual > (_U_UINT)expected)
971
+ Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > (_U_UINT)delta);
972
+ else
973
+ Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > (_U_UINT)delta);
974
+ }
975
+
976
+ if (Unity.CurrentTestFailed)
977
+ {
978
+ UnityTestResultsFailBegin(lineNumber);
979
+ UnityPrint(UnityStrDelta);
980
+ UnityPrintNumberByStyle(delta, style);
981
+ UnityPrint(UnityStrExpected);
982
+ UnityPrintNumberByStyle(expected, style);
983
+ UnityPrint(UnityStrWas);
984
+ UnityPrintNumberByStyle(actual, style);
985
+ UnityAddMsgIfSpecified(msg);
986
+ UNITY_FAIL_AND_BAIL;
987
+ }
988
+ }
989
+
990
+ //-----------------------------------------------
991
+ void UnityAssertEqualString(const char* expected,
992
+ const char* actual,
993
+ const char* msg,
994
+ const UNITY_LINE_TYPE lineNumber)
995
+ {
996
+ _UU32 i;
997
+
998
+ UNITY_SKIP_EXECUTION;
999
+
1000
+ // if both pointers not null compare the strings
1001
+ if (expected && actual)
1002
+ {
1003
+ for (i = 0; expected[i] || actual[i]; i++)
1004
+ {
1005
+ if (expected[i] != actual[i])
1006
+ {
1007
+ Unity.CurrentTestFailed = 1;
1008
+ break;
1009
+ }
1010
+ }
1011
+ }
1012
+ else
1013
+ { // handle case of one pointers being null (if both null, test should pass)
1014
+ if (expected != actual)
1015
+ {
1016
+ Unity.CurrentTestFailed = 1;
1017
+ }
1018
+ }
1019
+
1020
+ if (Unity.CurrentTestFailed)
1021
+ {
1022
+ UnityTestResultsFailBegin(lineNumber);
1023
+ UnityPrintExpectedAndActualStrings(expected, actual);
1024
+ UnityAddMsgIfSpecified(msg);
1025
+ UNITY_FAIL_AND_BAIL;
1026
+ }
1027
+ }
1028
+
1029
+ //-----------------------------------------------
1030
+ void UnityAssertEqualStringLen(const char* expected,
1031
+ const char* actual,
1032
+ const _UU32 length,
1033
+ const char* msg,
1034
+ const UNITY_LINE_TYPE lineNumber)
1035
+ {
1036
+ _UU32 i;
1037
+
1038
+ UNITY_SKIP_EXECUTION;
1039
+
1040
+ // if both pointers not null compare the strings
1041
+ if (expected && actual)
1042
+ {
1043
+ for (i = 0; (expected[i] || actual[i]) && i < length; i++)
1044
+ {
1045
+ if (expected[i] != actual[i])
1046
+ {
1047
+ Unity.CurrentTestFailed = 1;
1048
+ break;
1049
+ }
1050
+ }
1051
+ }
1052
+ else
1053
+ { // handle case of one pointers being null (if both null, test should pass)
1054
+ if (expected != actual)
1055
+ {
1056
+ Unity.CurrentTestFailed = 1;
1057
+ }
1058
+ }
1059
+
1060
+ if (Unity.CurrentTestFailed)
1061
+ {
1062
+ UnityTestResultsFailBegin(lineNumber);
1063
+ UnityPrintExpectedAndActualStringsLen(expected, actual, length);
1064
+ UnityAddMsgIfSpecified(msg);
1065
+ UNITY_FAIL_AND_BAIL;
1066
+ }
1067
+ }
1068
+
1069
+
1070
+ //-----------------------------------------------
1071
+ void UnityAssertEqualStringArray( const char** expected,
1072
+ const char** actual,
1073
+ const _UU32 num_elements,
1074
+ const char* msg,
1075
+ const UNITY_LINE_TYPE lineNumber)
1076
+ {
1077
+ _UU32 i, j = 0;
1078
+
1079
+ UNITY_SKIP_EXECUTION;
1080
+
1081
+ // if no elements, it's an error
1082
+ if (num_elements == 0)
1083
+ {
1084
+ UnityTestResultsFailBegin(lineNumber);
1085
+ UnityPrint(UnityStrPointless);
1086
+ UnityAddMsgIfSpecified(msg);
1087
+ UNITY_FAIL_AND_BAIL;
1088
+ }
1089
+
1090
+ if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE void*)expected, (UNITY_PTR_ATTRIBUTE void*)actual, lineNumber, msg) == 1)
1091
+ return;
1092
+
1093
+ do
1094
+ {
1095
+ // if both pointers not null compare the strings
1096
+ if (expected[j] && actual[j])
1097
+ {
1098
+ for (i = 0; expected[j][i] || actual[j][i]; i++)
1099
+ {
1100
+ if (expected[j][i] != actual[j][i])
1101
+ {
1102
+ Unity.CurrentTestFailed = 1;
1103
+ break;
1104
+ }
1105
+ }
1106
+ }
1107
+ else
1108
+ { // handle case of one pointers being null (if both null, test should pass)
1109
+ if (expected[j] != actual[j])
1110
+ {
1111
+ Unity.CurrentTestFailed = 1;
1112
+ }
1113
+ }
1114
+
1115
+ if (Unity.CurrentTestFailed)
1116
+ {
1117
+ UnityTestResultsFailBegin(lineNumber);
1118
+ if (num_elements > 1)
1119
+ {
1120
+ UnityPrint(UnityStrElement);
1121
+ UnityPrintNumberByStyle((j), UNITY_DISPLAY_STYLE_UINT);
1122
+ }
1123
+ UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j]));
1124
+ UnityAddMsgIfSpecified(msg);
1125
+ UNITY_FAIL_AND_BAIL;
1126
+ }
1127
+ } while (++j < num_elements);
1128
+ }
1129
+
1130
+ //-----------------------------------------------
1131
+ void UnityAssertEqualMemory( UNITY_PTR_ATTRIBUTE const void* expected,
1132
+ UNITY_PTR_ATTRIBUTE const void* actual,
1133
+ const _UU32 length,
1134
+ const _UU32 num_elements,
1135
+ const char* msg,
1136
+ const UNITY_LINE_TYPE lineNumber)
1137
+ {
1138
+ UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected;
1139
+ UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual;
1140
+ _UU32 elements = num_elements;
1141
+ _UU32 bytes;
1142
+
1143
+ UNITY_SKIP_EXECUTION;
1144
+
1145
+ if ((elements == 0) || (length == 0))
1146
+ {
1147
+ UnityTestResultsFailBegin(lineNumber);
1148
+ UnityPrint(UnityStrPointless);
1149
+ UnityAddMsgIfSpecified(msg);
1150
+ UNITY_FAIL_AND_BAIL;
1151
+ }
1152
+
1153
+ if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE const void*)expected, (UNITY_PTR_ATTRIBUTE const void*)actual, lineNumber, msg) == 1)
1154
+ return;
1155
+
1156
+ while (elements--)
1157
+ {
1158
+ /////////////////////////////////////
1159
+ bytes = length;
1160
+ while (bytes--)
1161
+ {
1162
+ if (*ptr_exp != *ptr_act)
1163
+ {
1164
+ UnityTestResultsFailBegin(lineNumber);
1165
+ UnityPrint(UnityStrMemory);
1166
+ if (num_elements > 1)
1167
+ {
1168
+ UnityPrint(UnityStrElement);
1169
+ UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
1170
+ }
1171
+ UnityPrint(UnityStrByte);
1172
+ UnityPrintNumberByStyle((length - bytes - 1), UNITY_DISPLAY_STYLE_UINT);
1173
+ UnityPrint(UnityStrExpected);
1174
+ UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8);
1175
+ UnityPrint(UnityStrWas);
1176
+ UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8);
1177
+ UnityAddMsgIfSpecified(msg);
1178
+ UNITY_FAIL_AND_BAIL;
1179
+ }
1180
+ ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 1);
1181
+ ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 1);
1182
+ }
1183
+ /////////////////////////////////////
1184
+
1185
+ }
1186
+ }
1187
+
1188
+ //-----------------------------------------------
1189
+ // Control Functions
1190
+ //-----------------------------------------------
1191
+
1192
+ void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
1193
+ {
1194
+ UNITY_SKIP_EXECUTION;
1195
+
1196
+ UnityTestResultsBegin(Unity.TestFile, line);
1197
+ UnityPrintFail();
1198
+ if (msg != NULL)
1199
+ {
1200
+ UNITY_OUTPUT_CHAR(':');
1201
+ if (msg[0] != ' ')
1202
+ {
1203
+ UNITY_OUTPUT_CHAR(' ');
1204
+ }
1205
+ UnityPrint(msg);
1206
+ }
1207
+ UNITY_FAIL_AND_BAIL;
1208
+ }
1209
+
1210
+ //-----------------------------------------------
1211
+ void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
1212
+ {
1213
+ UNITY_SKIP_EXECUTION;
1214
+
1215
+ UnityTestResultsBegin(Unity.TestFile, line);
1216
+ UnityPrint(UnityStrIgnore);
1217
+ if (msg != NULL)
1218
+ {
1219
+ UNITY_OUTPUT_CHAR(':');
1220
+ UNITY_OUTPUT_CHAR(' ');
1221
+ UnityPrint(msg);
1222
+ }
1223
+ UNITY_IGNORE_AND_BAIL;
1224
+ }
1225
+
1226
+ //-----------------------------------------------
1227
+ #if defined(UNITY_WEAK_ATTRIBUTE)
1228
+ void setUp(void);
1229
+ void tearDown(void);
1230
+ UNITY_WEAK_ATTRIBUTE void setUp(void) { }
1231
+ UNITY_WEAK_ATTRIBUTE void tearDown(void) { }
1232
+ #elif defined(UNITY_WEAK_PRAGMA)
1233
+ # pragma weak setUp
1234
+ void setUp(void);
1235
+ # pragma weak tearDown
1236
+ void tearDown(void);
1237
+ #else
1238
+ void setUp(void);
1239
+ void tearDown(void);
1240
+ #endif
1241
+ //-----------------------------------------------
1242
+ void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
1243
+ {
1244
+ Unity.CurrentTestName = FuncName;
1245
+ Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum;
1246
+ Unity.NumberOfTests++;
1247
+ if (TEST_PROTECT())
1248
+ {
1249
+ setUp();
1250
+ Func();
1251
+ }
1252
+ if (TEST_PROTECT() && !(Unity.CurrentTestIgnored))
1253
+ {
1254
+ tearDown();
1255
+ }
1256
+ UnityConcludeTest();
1257
+ }
1258
+
1259
+ //-----------------------------------------------
1260
+ void UnityBegin(const char* filename)
1261
+ {
1262
+ Unity.TestFile = filename;
1263
+ Unity.CurrentTestName = NULL;
1264
+ Unity.CurrentTestLineNumber = 0;
1265
+ Unity.NumberOfTests = 0;
1266
+ Unity.TestFailures = 0;
1267
+ Unity.TestIgnores = 0;
1268
+ Unity.CurrentTestFailed = 0;
1269
+ Unity.CurrentTestIgnored = 0;
1270
+
1271
+ UNITY_OUTPUT_START();
1272
+ }
1273
+
1274
+ //-----------------------------------------------
1275
+ int UnityEnd(void)
1276
+ {
1277
+ UNITY_PRINT_EOL;
1278
+ UnityPrint(UnityStrBreaker);
1279
+ UNITY_PRINT_EOL;
1280
+ UnityPrintNumber((_U_SINT)(Unity.NumberOfTests));
1281
+ UnityPrint(UnityStrResultsTests);
1282
+ UnityPrintNumber((_U_SINT)(Unity.TestFailures));
1283
+ UnityPrint(UnityStrResultsFailures);
1284
+ UnityPrintNumber((_U_SINT)(Unity.TestIgnores));
1285
+ UnityPrint(UnityStrResultsIgnored);
1286
+ UNITY_PRINT_EOL;
1287
+ if (Unity.TestFailures == 0U)
1288
+ {
1289
+ UnityPrintOk();
1290
+ }
1291
+ else
1292
+ {
1293
+ UnityPrintFail();
1294
+ }
1295
+ UNITY_PRINT_EOL;
1296
+ UNITY_OUTPUT_COMPLETE();
1297
+ return (int)(Unity.TestFailures);
1298
+ }
1299
+
1300
+ //-----------------------------------------------