trackler 1.0.4.0 → 1.0.4.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/common/CONTRIBUTING.md +17 -2
- data/common/exercises/anagram/canonical-data.json +0 -14
- data/common/exercises/pig-latin/canonical-data.json +6 -1
- data/common/exercises/raindrops/description.md +4 -4
- data/common/exercises/raindrops/metadata.yml +1 -1
- data/common/exercises/roman-numerals/metadata.yml +1 -1
- data/lib/trackler/version.rb +1 -1
- data/tracks/c/config.json +12 -1
- data/tracks/c/exercises/roman-numerals/makefile +16 -0
- data/tracks/c/exercises/roman-numerals/src/example.c +43 -0
- data/tracks/c/exercises/roman-numerals/src/example.h +6 -0
- data/tracks/c/exercises/roman-numerals/test/test_roman_numerals.c +126 -0
- data/tracks/c/exercises/roman-numerals/test/vendor/unity.c +1300 -0
- data/tracks/c/exercises/roman-numerals/test/vendor/unity.h +274 -0
- data/tracks/c/exercises/roman-numerals/test/vendor/unity_internals.h +701 -0
- data/tracks/clojure/exercises/flatten-array/project.clj +4 -0
- data/tracks/csharp/exercises/protein-translation/ProteinTranslationTest.cs +1 -1
- data/tracks/elixir/exercises/bowling/bowling_test.exs +157 -62
- data/tracks/elixir/exercises/bowling/example.exs +33 -4
- data/tracks/erlang/config.json +176 -36
- data/tracks/go/.travis.yml +7 -1
- data/tracks/go/bin/test-without-stubs +29 -0
- data/tracks/go/exercises/robot-simulator/defs.go +1 -1
- data/tracks/go/exercises/variable-length-quantity/variable_length_quantity_test.go +31 -25
- data/tracks/haskell/.travis.yml +9 -5
- data/tracks/haskell/config.json +127 -121
- data/tracks/haskell/exercises/leap/src/LeapYear.hs +1 -1
- data/tracks/haskell/exercises/space-age/HINTS.md +14 -2
- data/tracks/haskell/exercises/space-age/{src/Example.hs → examples/success-double/SpaceAge.hs} +0 -0
- data/tracks/haskell/exercises/space-age/examples/success-double/package.yaml +19 -0
- data/tracks/haskell/exercises/space-age/examples/success-rational/SpaceAge.hs +24 -0
- data/tracks/haskell/exercises/space-age/examples/success-rational/package.yaml +19 -0
- data/tracks/haskell/exercises/space-age/src/SpaceAge.hs +4 -1
- data/tracks/haskell/exercises/space-age/test/Tests.hs +12 -5
- data/tracks/haskell/exercises/word-count/HINTS.md +21 -0
- data/tracks/haskell/exercises/word-count/examples/success-newtype/WordCount.hs +31 -0
- data/tracks/haskell/exercises/word-count/examples/success-newtype/package.yaml +21 -0
- data/tracks/haskell/exercises/word-count/examples/success-simple/WordCount.hs +13 -0
- data/tracks/haskell/exercises/word-count/examples/success-simple/package.yaml +20 -0
- data/tracks/haskell/exercises/word-count/package.yaml +0 -2
- data/tracks/haskell/exercises/word-count/src/WordCount.hs +2 -1
- data/tracks/haskell/exercises/word-count/test/Tests.hs +15 -6
- data/tracks/haskell/exercises/zebra-puzzle/package.yaml +19 -0
- data/tracks/haskell/exercises/zebra-puzzle/src/Example.hs +113 -0
- data/tracks/haskell/exercises/zebra-puzzle/src/ZebraPuzzle.hs +12 -0
- data/tracks/haskell/exercises/zebra-puzzle/stack.yaml +1 -0
- data/tracks/haskell/exercises/zebra-puzzle/test/Tests.hs +13 -0
- data/tracks/javascript/exercises/beer-song/beer-song.spec.js +5 -0
- data/tracks/lisp/config.json +147 -0
- data/tracks/ocaml/config.json +12 -0
- data/tracks/ocaml/exercises/atbash-cipher/.merlin +5 -0
- data/tracks/ocaml/exercises/atbash-cipher/HINTS.md +17 -0
- data/tracks/ocaml/exercises/atbash-cipher/Makefile +11 -0
- data/tracks/ocaml/exercises/atbash-cipher/atbash_cipher.mli +5 -0
- data/tracks/ocaml/exercises/atbash-cipher/example.ml +47 -0
- data/tracks/ocaml/exercises/atbash-cipher/test.ml +37 -0
- data/tracks/ocaml/exercises/meetup/.merlin +5 -0
- data/tracks/ocaml/exercises/meetup/Makefile +11 -0
- data/tracks/ocaml/exercises/meetup/example.ml +63 -0
- data/tracks/ocaml/exercises/meetup/meetup.mli +7 -0
- data/tracks/ocaml/exercises/meetup/test.ml +786 -0
- data/tracks/php/exercises/bowling/bowling_test.php +233 -10
- data/tracks/php/exercises/bowling/example.php +49 -6
- data/tracks/python/.travis.yml +5 -0
- data/tracks/python/config.json +33 -1
- data/tracks/python/exercises/flatten-array/example.py +18 -0
- data/tracks/python/exercises/flatten-array/flatten_array_test.py +40 -0
- data/tracks/python/exercises/robot-name/robot_name_test.py +8 -2
- data/tracks/r/config.json +32 -8
- data/tracks/ruby/bin/enable-executable +9 -5
- data/tracks/ruby/bin/executable-tests-check +7 -3
- data/tracks/ruby/bin/local-status-check +4 -4
- data/tracks/ruby/config.json +8 -1
- data/tracks/ruby/exercises/acronym/acronym_test.rb +0 -1
- data/tracks/ruby/exercises/anagram/.version +1 -0
- data/tracks/ruby/exercises/anagram/anagram_test.rb +101 -31
- data/tracks/ruby/exercises/anagram/example.rb +4 -0
- data/tracks/ruby/exercises/anagram/example.tt +19 -0
- data/tracks/ruby/exercises/gigasecond/.version +1 -1
- data/tracks/ruby/exercises/gigasecond/example.rb +1 -1
- data/tracks/ruby/exercises/gigasecond/gigasecond_test.rb +2 -2
- data/tracks/ruby/exercises/isogram/.version +1 -0
- data/tracks/ruby/exercises/isogram/example.rb +10 -0
- data/tracks/ruby/exercises/isogram/example.tt +20 -0
- data/tracks/ruby/exercises/isogram/isogram_test.rb +90 -0
- data/tracks/ruby/exercises/poker/example.rb +97 -39
- data/tracks/ruby/exercises/poker/poker_test.rb +67 -36
- data/tracks/ruby/exercises/sieve/.version +1 -0
- data/tracks/ruby/exercises/sieve/example.rb +4 -0
- data/tracks/ruby/exercises/sieve/example.tt +21 -0
- data/tracks/ruby/exercises/sieve/sieve_test.rb +36 -13
- data/tracks/ruby/exercises/word-count/example.tt +4 -3
- data/tracks/ruby/exercises/word-count/word_count_test.rb +38 -48
- data/tracks/ruby/lib/anagram_cases.rb +42 -0
- data/tracks/ruby/lib/isogram_cases.rb +24 -0
- data/tracks/ruby/lib/sieve_cases.rb +33 -0
- data/tracks/ruby/lib/word_count_cases.rb +19 -0
- data/tracks/scala/config.json +21 -0
- data/tracks/scala/docs/RESOURCES.md +1 -0
- data/tracks/scala/exercises/bracket-push/build.sbt +4 -0
- data/tracks/scala/exercises/bracket-push/example.scala +23 -0
- data/tracks/scala/exercises/bracket-push/src/main/scala/.keep +0 -0
- data/tracks/scala/exercises/bracket-push/src/test/scala/BracketsTest.scala +68 -0
- data/tracks/scala/exercises/change/src/test/scala/ChangeTest.scala +7 -0
- data/tracks/scala/exercises/sgf-parsing/build.sbt +7 -0
- data/tracks/scala/exercises/sgf-parsing/example.scala +66 -0
- data/tracks/scala/exercises/sgf-parsing/src/main/scala/.keep +0 -0
- data/tracks/scala/exercises/sgf-parsing/src/main/scala/Sgf.scala +17 -0
- data/tracks/scala/exercises/sgf-parsing/src/test/scala/SgfTest.scala +66 -0
- data/tracks/scala/exercises/zebra-puzzle/build.sbt +3 -0
- data/tracks/scala/exercises/zebra-puzzle/example.scala +152 -0
- data/tracks/scala/exercises/zebra-puzzle/src/main/scala/.keep +0 -0
- data/tracks/scala/exercises/zebra-puzzle/src/main/scala/ZebraPuzzle.scala +14 -0
- data/tracks/scala/exercises/zebra-puzzle/src/test/scala/ZebraPuzzleTest.scala +11 -0
- data/tracks/scala/testgen/src/main/scala/BracketPushTestGenerator.scala +44 -0
- metadata +63 -3
- data/tracks/haskell/exercises/word-count/src/Example.hs +0 -8
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA1:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: 666616edfee42aeefbcb127b51ba18fe325933f8
|
4
|
+
data.tar.gz: 186cd5b3ca66ed36e9cc12f3b183c18f44c2f08d
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: a211e0c662bae14dd0c3242238f6f147d1a3d5fc090fecf16a9809fc4a7163c6a7cc665fb4a18eabc78ee43e58b0b35d316ac832e8aa2e8242f0a753d4e17163
|
7
|
+
data.tar.gz: 4ea81249e8ab5d409d956410792f277c2ca4ed7d8e28eb724d52ad8f8302e1b482028003675e050b4c544ca904a235070f197162b3529be50eb08c12db636969
|
data/common/CONTRIBUTING.md
CHANGED
@@ -377,8 +377,23 @@ A problem must have a unique slug. This slug is used as
|
|
377
377
|
this **must not** be merged until the exercism/x-common PR is merged.
|
378
378
|
|
379
379
|
## Improving Consistency By Extracting Shared Test Data
|
380
|
-
|
381
|
-
|
380
|
+
The goal is to have a file `exercises/<slug>/canonical-data.json` for each exercise in this repository. This JSON file should contain the generic (i.e. language independent) test data for that exercise. With this the quality of the tracks can be improved, e.g. fixes or new tests can be propagated to all the tracks. They can then be implemented manually or by running the test generator. (See [this issue](https://github.com/exercism/todo/issues/13) for more background info.)
|
381
|
+
|
382
|
+
The following steps help you extracting the canonical test data.
|
383
|
+
|
384
|
+
1. Select the exercise for which you want to create the shared test data from the [list of open todos](https://github.com/exercism/todo/issues?q=is%3Aissue+is%3Aopen+label%3Ashared-test-data)
|
385
|
+
2. Now you need to find the existing tests. You can get a list with links to the all of those one of two ways
|
386
|
+
* Search for the exercise in this list http://x.exercism.io/v3/problems/data-todos (your browser might need a JSON viewer plugin/add-on to show this)
|
387
|
+
* Run this command in your terminal `curl http://x.exercism.io/v3/problems/data-todos | jq '.[] | map(select(.["slug"] == "accumulate"))'`. Replace `accumulate` with the name of the exercise you have chosen.
|
388
|
+
3. Open the links in different browser tabs, navigate to the test files and read through the tests. Look for test cases that all/many of the languages have in common and identify outliers that only appear in one or two languages. It might be helpful to make some notes on your findings.
|
389
|
+
4. Now it's time to write the canonical-data.json file. Look at examples like [the test data for hamming](https://github.com/exercism/x-common/blob/master/exercises/hamming/canonical-data.json) and check the [readme](https://github.com/exercism/x-common#test-data-format-canonical-datajson) to find out how to best structure the JSON file.
|
390
|
+
From what you learned in step 3 decide for a sensible set of test cases. The following considerations might help with that.
|
391
|
+
* Try to stick to test cases that already occur in many languages so it is feasible for the track maintainers to adapt to the canonical set.
|
392
|
+
* All tests should be essential to the problem. Ensure people can get the first test passing easily. Then each following test should ideally add a little functionality. People should be able to solve the problem a little at a time. Avoid test cases that don't introduce any new aspect and would already pass anyway.
|
393
|
+
* The test cases should not require people to follow one very specific way to solve the problem, e.g. the tests should avoid checking for helper functions that might not be present in other implementations.
|
394
|
+
* Performance tests should not be included in the canonical test data.
|
395
|
+
|
396
|
+
If you are unsure about all these considerations just make a pull request with an initial proposal and ask the community for help.
|
382
397
|
|
383
398
|
## Writing a New Test Suite Generator
|
384
399
|
|
@@ -98,20 +98,6 @@
|
|
98
98
|
"candidates": ["patter"],
|
99
99
|
"expected": []
|
100
100
|
},
|
101
|
-
{
|
102
|
-
"description": "detects unicode anagrams",
|
103
|
-
"comment": "These words don't make sense, they're just greek letters cobbled together.",
|
104
|
-
"subject": "ΑΒΓ",
|
105
|
-
"candidates": ["ΒΓΑ", "ΒΓΔ", "γβα"],
|
106
|
-
"expected": ["ΒΓΑ", "γβα"]
|
107
|
-
},
|
108
|
-
{
|
109
|
-
"description": "eliminates misleading unicode anagrams",
|
110
|
-
"comment": "Despite what a human might think these words different letters, the candidates uses Greek A and B while the list of potential anagrams uses Latin A and B.",
|
111
|
-
"subject": "ΑΒΓ",
|
112
|
-
"candidates": ["ABΓ"],
|
113
|
-
"expected": []
|
114
|
-
},
|
115
101
|
{
|
116
102
|
"description": "capital word is not own anagram",
|
117
103
|
"subject": "BANANA",
|
@@ -31,6 +31,11 @@
|
|
31
31
|
"description" : "word beginning with u",
|
32
32
|
"input" : "under",
|
33
33
|
"expected" : "underay"
|
34
|
+
},
|
35
|
+
{
|
36
|
+
"description" : "word beginning with a vowel and followed by a qu",
|
37
|
+
"input" : "equal",
|
38
|
+
"expected" : "equalay"
|
34
39
|
}
|
35
40
|
]
|
36
41
|
},
|
@@ -125,4 +130,4 @@
|
|
125
130
|
]
|
126
131
|
}
|
127
132
|
]
|
128
|
-
}
|
133
|
+
}
|
@@ -1,7 +1,7 @@
|
|
1
|
-
- If the number
|
2
|
-
- If the number
|
3
|
-
- If the number
|
4
|
-
- If the number does not
|
1
|
+
- If the number has 3 as a factor, output 'Pling'.
|
2
|
+
- If the number has 5 as a factor, output 'Plang'.
|
3
|
+
- If the number has 7 as a factor, output 'Plong'.
|
4
|
+
- If the number does not have 3, 5, or 7 as a factor,
|
5
5
|
just pass the number's digits straight through.
|
6
6
|
|
7
7
|
## Examples
|
@@ -1,4 +1,4 @@
|
|
1
1
|
---
|
2
|
-
blurb: "Write a program that converts a number to a string, the contents of which
|
2
|
+
blurb: "Write a program that converts a number to a string, the contents of which depend on the number's factors."
|
3
3
|
source: "A variation on a famous interview question intended to weed out potential candidates."
|
4
4
|
source_url: "http://jumpstartlab.com"
|
data/lib/trackler/version.rb
CHANGED
data/tracks/c/config.json
CHANGED
@@ -20,7 +20,8 @@
|
|
20
20
|
"rna-transcription",
|
21
21
|
"difference-of-squares",
|
22
22
|
"sum-of-multiples",
|
23
|
-
"binary-search"
|
23
|
+
"binary-search",
|
24
|
+
"roman-numerals"
|
24
25
|
],
|
25
26
|
"exercises": [{
|
26
27
|
"slug": "hello-world",
|
@@ -144,6 +145,16 @@
|
|
144
145
|
"control-flow (loops)",
|
145
146
|
"searching"
|
146
147
|
]
|
148
|
+
}, {
|
149
|
+
"difficulty": 3,
|
150
|
+
"slug": "roman-numerals",
|
151
|
+
"topics": [
|
152
|
+
"arrays",
|
153
|
+
"memory management",
|
154
|
+
"structs",
|
155
|
+
"control-flow (loops)",
|
156
|
+
"strings"
|
157
|
+
]
|
147
158
|
}],
|
148
159
|
"deprecated": [
|
149
160
|
|
@@ -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_roman_numerals.c src/roman_numerals.c src/roman_numerals.h
|
15
|
+
@echo Compiling $@
|
16
|
+
@cc $(CFLAGS) src/roman_numerals.c test/vendor/unity.c test/test_roman_numerals.c -o tests.out
|
@@ -0,0 +1,43 @@
|
|
1
|
+
#include "roman_numerals.h"
|
2
|
+
#include <stdlib.h>
|
3
|
+
#include <string.h>
|
4
|
+
|
5
|
+
#define NUM_OF_ELEMENTS(a) (sizeof(a) / sizeof(a[0]))
|
6
|
+
#define MAX_NUMERAL_LENGTH (7)
|
7
|
+
|
8
|
+
typedef struct
|
9
|
+
{
|
10
|
+
char *numeral;
|
11
|
+
unsigned int value;
|
12
|
+
} numeral_values_t;
|
13
|
+
|
14
|
+
const numeral_values_t numeral_values[] =
|
15
|
+
{
|
16
|
+
{ "M", 1000 },
|
17
|
+
{ "CM", 900 },
|
18
|
+
{ "D", 500 },
|
19
|
+
{ "CD", 400 },
|
20
|
+
{ "C", 100 },
|
21
|
+
{ "XC", 90 },
|
22
|
+
{ "L", 50 },
|
23
|
+
{ "XL", 40 },
|
24
|
+
{ "X", 10 },
|
25
|
+
{ "IX", 9 },
|
26
|
+
{ "V", 5 },
|
27
|
+
{ "IV", 4 },
|
28
|
+
{ "I", 1 }
|
29
|
+
};
|
30
|
+
|
31
|
+
char * to_roman_numeral(unsigned int number)
|
32
|
+
{
|
33
|
+
char *numerals = calloc(0, sizeof(char) * MAX_NUMERAL_LENGTH);
|
34
|
+
|
35
|
+
for (size_t i = 0; i < NUM_OF_ELEMENTS(numeral_values); i++) {
|
36
|
+
while (number >= numeral_values[i].value) {
|
37
|
+
strncat(numerals, numeral_values[i].numeral, MAX_NUMERAL_LENGTH - strlen(numerals));
|
38
|
+
number -= numeral_values[i].value;
|
39
|
+
}
|
40
|
+
}
|
41
|
+
|
42
|
+
return numerals;
|
43
|
+
}
|
@@ -0,0 +1,126 @@
|
|
1
|
+
#include "vendor/unity.h"
|
2
|
+
#include "../src/roman_numerals.h"
|
3
|
+
#include <stdlib.h>
|
4
|
+
|
5
|
+
static void test_conversion(int number, char *expected)
|
6
|
+
{
|
7
|
+
char *result = to_roman_numeral(number);
|
8
|
+
TEST_ASSERT_EQUAL_STRING(expected, result);
|
9
|
+
free(result);
|
10
|
+
}
|
11
|
+
void test_one_yields_I(void)
|
12
|
+
{
|
13
|
+
test_conversion(1, "I");
|
14
|
+
}
|
15
|
+
|
16
|
+
void test_two_yields_II(void)
|
17
|
+
{
|
18
|
+
test_conversion(2, "II");
|
19
|
+
}
|
20
|
+
|
21
|
+
void test_three_yields_III(void)
|
22
|
+
{
|
23
|
+
test_conversion(3, "III");
|
24
|
+
}
|
25
|
+
|
26
|
+
void test_four_yields_IV(void)
|
27
|
+
{
|
28
|
+
test_conversion(4, "IV");
|
29
|
+
}
|
30
|
+
|
31
|
+
void test_five_yields_V(void)
|
32
|
+
{
|
33
|
+
test_conversion(5, "V");
|
34
|
+
}
|
35
|
+
|
36
|
+
void test_six_yields_VI(void)
|
37
|
+
{
|
38
|
+
test_conversion(6, "VI");
|
39
|
+
}
|
40
|
+
|
41
|
+
void test_nine_yields_IX(void)
|
42
|
+
{
|
43
|
+
test_conversion(9, "IX");
|
44
|
+
}
|
45
|
+
|
46
|
+
void test_twenty_seven_yields_XXVII(void)
|
47
|
+
{
|
48
|
+
test_conversion(27, "XXVII");
|
49
|
+
}
|
50
|
+
|
51
|
+
void test_forty_eight_yields_XLVIII(void)
|
52
|
+
{
|
53
|
+
test_conversion(48, "XLVIII");
|
54
|
+
}
|
55
|
+
|
56
|
+
void test_fifty_nine_yields_LIX(void)
|
57
|
+
{
|
58
|
+
test_conversion(59, "LIX");
|
59
|
+
}
|
60
|
+
|
61
|
+
void test_ninety_three_yields_XCIII(void)
|
62
|
+
{
|
63
|
+
test_conversion(93, "XCIII");
|
64
|
+
}
|
65
|
+
|
66
|
+
void test_one_hundred_forty_one_yields_CXLI(void)
|
67
|
+
{
|
68
|
+
test_conversion(141, "CXLI");
|
69
|
+
}
|
70
|
+
|
71
|
+
void test_one_hundred_sixty_three_yields_CLXIII(void)
|
72
|
+
{
|
73
|
+
test_conversion(163, "CLXIII");
|
74
|
+
}
|
75
|
+
|
76
|
+
void test_four_hundred_two_yields_CDII(void)
|
77
|
+
{
|
78
|
+
test_conversion(402, "CDII");
|
79
|
+
}
|
80
|
+
|
81
|
+
void test_five_hundred_seventy_five_yields_DLXXV(void)
|
82
|
+
{
|
83
|
+
test_conversion(575, "DLXXV");
|
84
|
+
}
|
85
|
+
|
86
|
+
void test_nine_hundred_eleven_yields_CMXI(void)
|
87
|
+
{
|
88
|
+
test_conversion(911, "CMXI");
|
89
|
+
}
|
90
|
+
|
91
|
+
void test_one_thousand_twenty_four_yields_MXXIV(void)
|
92
|
+
{
|
93
|
+
test_conversion(1024, "MXXIV");
|
94
|
+
}
|
95
|
+
|
96
|
+
void test_three_thousand_yields_MMM(void)
|
97
|
+
{
|
98
|
+
test_conversion(3000, "MMM");
|
99
|
+
}
|
100
|
+
|
101
|
+
int main(void)
|
102
|
+
{
|
103
|
+
UnityBegin("test/test_roman_numerals.c");
|
104
|
+
|
105
|
+
RUN_TEST(test_one_yields_I);
|
106
|
+
RUN_TEST(test_two_yields_II);
|
107
|
+
RUN_TEST(test_three_yields_III);
|
108
|
+
RUN_TEST(test_four_yields_IV);
|
109
|
+
RUN_TEST(test_five_yields_V);
|
110
|
+
RUN_TEST(test_nine_yields_IX);
|
111
|
+
RUN_TEST(test_six_yields_VI);
|
112
|
+
RUN_TEST(test_twenty_seven_yields_XXVII);
|
113
|
+
RUN_TEST(test_forty_eight_yields_XLVIII);
|
114
|
+
RUN_TEST(test_fifty_nine_yields_LIX);
|
115
|
+
RUN_TEST(test_ninety_three_yields_XCIII);
|
116
|
+
RUN_TEST(test_one_hundred_forty_one_yields_CXLI);
|
117
|
+
RUN_TEST(test_one_hundred_sixty_three_yields_CLXIII);
|
118
|
+
RUN_TEST(test_four_hundred_two_yields_CDII);
|
119
|
+
RUN_TEST(test_five_hundred_seventy_five_yields_DLXXV);
|
120
|
+
RUN_TEST(test_nine_hundred_eleven_yields_CMXI);
|
121
|
+
RUN_TEST(test_one_thousand_twenty_four_yields_MXXIV);
|
122
|
+
RUN_TEST(test_three_thousand_yields_MMM);
|
123
|
+
|
124
|
+
UnityEnd();
|
125
|
+
return 0;
|
126
|
+
}
|
@@ -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
|
+
//-----------------------------------------------
|