trackler 2.0.3.0 → 2.0.3.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (110) hide show
  1. checksums.yaml +4 -4
  2. data/fixtures/common/exercises/no-metadata/description.md +1 -0
  3. data/lib/trackler/problem.rb +12 -0
  4. data/lib/trackler/problems.rb +8 -12
  5. data/lib/trackler/version.rb +1 -1
  6. data/tracks/bash/README.md +2 -0
  7. data/tracks/c/config.json +9 -2
  8. data/tracks/c/exercises/sieve/makefile +15 -0
  9. data/tracks/c/exercises/sieve/src/example.c +50 -0
  10. data/tracks/c/exercises/sieve/src/sieve.h +10 -0
  11. data/tracks/c/exercises/sieve/test/test_sieve.c +113 -0
  12. data/tracks/c/exercises/sieve/test/vendor/unity.c +1300 -0
  13. data/tracks/c/exercises/sieve/test/vendor/unity.h +274 -0
  14. data/tracks/c/exercises/sieve/test/vendor/unity_internals.h +701 -0
  15. data/tracks/coffeescript/.travis.yml +1 -0
  16. data/tracks/coldfusion/.travis.yml +1 -0
  17. data/tracks/crystal/Makefile +18 -15
  18. data/tracks/crystal/README.md +5 -5
  19. data/tracks/crystal/config.json +6 -0
  20. data/tracks/crystal/exercises/acronym/src/acronym.cr +1 -0
  21. data/tracks/crystal/exercises/anagram/src/anagram.cr +1 -0
  22. data/tracks/crystal/exercises/atbash-cipher/src/atbash_cipher.cr +1 -0
  23. data/tracks/crystal/exercises/binary/src/binary.cr +1 -0
  24. data/tracks/crystal/exercises/bob/src/bob.cr +1 -0
  25. data/tracks/crystal/exercises/bracket-push/src/bracket_push.cr +1 -0
  26. data/tracks/crystal/exercises/difference-of-squares/spec/difference_of_squares_spec.cr +44 -0
  27. data/tracks/crystal/exercises/difference-of-squares/src/example.cr +15 -0
  28. data/tracks/crystal/exercises/forth/src/forth.cr +1 -0
  29. data/tracks/crystal/exercises/gigasecond/src/gigasecond.cr +1 -0
  30. data/tracks/crystal/exercises/hamming/src/hamming.cr +1 -0
  31. data/tracks/crystal/exercises/hello-world/src/hello_world.cr +1 -0
  32. data/tracks/crystal/exercises/largest-series-product/src/largest_series_product.cr +1 -0
  33. data/tracks/crystal/exercises/leap/src/leap.cr +1 -0
  34. data/tracks/crystal/exercises/pangram/src/pangram.cr +1 -0
  35. data/tracks/crystal/exercises/raindrops/src/raindrops.cr +1 -0
  36. data/tracks/crystal/exercises/react/src/react.cr +1 -0
  37. data/tracks/crystal/exercises/rna-transcription/src/rna_transcription.cr +1 -0
  38. data/tracks/crystal/exercises/roman-numerals/src/roman_numerals.cr +1 -0
  39. data/tracks/crystal/exercises/sieve/src/sieve.cr +1 -0
  40. data/tracks/crystal/src/generator/exercises/difference_of_squares.cr +39 -0
  41. data/tracks/go/exercises/allergies/allergies_test.go +2 -2
  42. data/tracks/go/exercises/anagram/anagram_test.go +3 -3
  43. data/tracks/go/exercises/grade-school/grade_school_test.go +3 -3
  44. data/tracks/go/exercises/secret-handshake/secret_handshake_test.go +1 -1
  45. data/tracks/java/config.json +13 -1
  46. data/tracks/java/exercises/binary-search-tree/build.gradle +18 -0
  47. data/tracks/java/exercises/binary-search-tree/src/example/java/BST.java +122 -0
  48. data/tracks/java/exercises/binary-search-tree/src/main/java/.keep +0 -0
  49. data/tracks/java/exercises/binary-search-tree/src/test/java/.keep +0 -0
  50. data/tracks/java/exercises/binary-search-tree/src/test/java/BSTTest.java +163 -0
  51. data/tracks/java/exercises/pythagorean-triplet/build.gradle +18 -0
  52. data/tracks/java/exercises/pythagorean-triplet/src/example/java/PythagoreanTriplet.java +117 -0
  53. data/tracks/java/exercises/pythagorean-triplet/src/main/java/PythagoreanTriplet.java +3 -0
  54. data/tracks/java/exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java +95 -0
  55. data/tracks/java/exercises/settings.gradle +2 -0
  56. data/tracks/julia/README.md +16 -0
  57. data/tracks/perl5/README.md +2 -0
  58. data/tracks/perl6/README.md +2 -1
  59. data/tracks/php/config.json +5 -0
  60. data/tracks/php/exercises/sieve/example.php +29 -0
  61. data/tracks/php/exercises/sieve/sieve_test.php +201 -0
  62. data/tracks/pony/.travis.yml +1 -0
  63. data/tracks/python/exercises/anagram/anagram_test.py +1 -0
  64. data/tracks/python/exercises/beer-song/beer_song_test.py +1 -0
  65. data/tracks/python/exercises/binary-search/binary_search_test.py +1 -0
  66. data/tracks/python/exercises/binary/binary_test.py +1 -0
  67. data/tracks/python/exercises/bob/bob_test.py +1 -0
  68. data/tracks/python/exercises/clock/clock_test.py +1 -0
  69. data/tracks/python/exercises/etl/etl_test.py +1 -0
  70. data/tracks/python/exercises/gigasecond/gigasecond_test.py +1 -0
  71. data/tracks/python/exercises/grains/grains_test.py +1 -0
  72. data/tracks/python/exercises/leap/leap_test.py +1 -0
  73. data/tracks/python/exercises/meetup/meetup_test.py +1 -0
  74. data/tracks/python/exercises/nucleotide-count/nucleotide_count_test.py +1 -0
  75. data/tracks/python/exercises/ocr-numbers/example.py +1 -0
  76. data/tracks/python/exercises/ocr-numbers/ocr_test.py +1 -0
  77. data/tracks/python/exercises/perfect-numbers/perfect_numbers_test.py +1 -0
  78. data/tracks/python/exercises/phone-number/phone_number_test.py +1 -0
  79. data/tracks/python/exercises/pig-latin/pig_latin_test.py +1 -0
  80. data/tracks/python/exercises/point-mutations/point_mutations_test.py +1 -0
  81. data/tracks/python/exercises/poker/poker_test.py +1 -0
  82. data/tracks/python/exercises/prime-factors/prime_factors_test.py +1 -0
  83. data/tracks/python/exercises/pythagorean-triplet/example.py +2 -3
  84. data/tracks/python/exercises/rail-fence-cipher/rail_fence_cipher_test.py +1 -0
  85. data/tracks/python/exercises/raindrops/raindrops_test.py +1 -0
  86. data/tracks/python/exercises/rectangles/rectangles_count_test.py +1 -0
  87. data/tracks/python/exercises/robot-simulator/robot_simulator_test.py +1 -0
  88. data/tracks/python/exercises/roman-numerals/roman_numerals_test.py +1 -0
  89. data/tracks/python/exercises/run-length-encoding/run_length_test.py +1 -0
  90. data/tracks/python/exercises/say/say_test.py +1 -0
  91. data/tracks/python/exercises/scrabble-score/scrabble_score_test.py +1 -0
  92. data/tracks/python/exercises/sieve/sieve_test.py +1 -0
  93. data/tracks/python/exercises/space-age/space_age_test.py +1 -0
  94. data/tracks/python/exercises/triangle/triangle_test.py +1 -0
  95. data/tracks/python/exercises/word-count/word_count_test.py +1 -0
  96. data/tracks/python/requirements-travis.txt +1 -1
  97. data/tracks/ruby/docs/24pullrequests.md +21 -0
  98. data/tracks/ruby/exercises/bowling/.version +1 -1
  99. data/tracks/ruby/exercises/bowling/bowling_test.rb +44 -15
  100. data/tracks/ruby/exercises/bowling/example.rb +10 -5
  101. data/tracks/ruby/exercises/bowling/example.tt +4 -2
  102. data/tracks/ruby/lib/bowling_cases.rb +1 -1
  103. data/tracks/scala/exercises/bank-account/HINTS.md +11 -0
  104. data/tracks/scala/exercises/bank-account/example.scala +2 -4
  105. data/tracks/scala/exercises/bank-account/src/main/scala/BankAccount.scala +13 -0
  106. data/tracks/scala/exercises/bank-account/src/test/scala/BankAccountTest.scala +5 -5
  107. data/tracks/scala/exercises/hamming/HINTS.md +57 -0
  108. data/tracks/scala/exercises/hello-world/HINTS.md +8 -0
  109. data/tracks/scala/exercises/nucleotide-count/HINTS.md +61 -0
  110. metadata +48 -2
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: af2d2b8c82f965a8914c291da780b96a186b7e19
4
- data.tar.gz: ca7dabe7e72a3fab91c0ea17ca7dd2673e2813d5
3
+ metadata.gz: 47d31f451f039cad72c005eef342585e6f50f1cd
4
+ data.tar.gz: 38f5eec1ca3487b0e5b50c878fd1cadcabbe7096
5
5
  SHA512:
6
- metadata.gz: 289db48edd0943bc6fd57df022487c3d7c2ee414a87825e763386650cc014ee1708c1dea059b224f36de18c9259b2e4ddb186edc43e153fd09b70722da8899e1
7
- data.tar.gz: 608b17ce663f4d05e8e28ee5bf6d14708302cace6f94ec295ff9c3dc6f71f367dcf1835119c3e62447a5559e99303a588733df8b67402c50005974da979d124a
6
+ metadata.gz: 8897f583647e82cec1fba04537a5b71747e7051535a8b214f83019e739130e57decb44e62754eafa94e23cd6e7ec6a943a8d3fb5d6bc409eb48f40ea61a6f764
7
+ data.tar.gz: 55639827fd62d7fd2da4ef46489d01c37cdc30a1f1bda9e37f72b06953108e6207778ec815342f016105fb5916b082f4441ef3e64df964068bfd73108d02eb2a
@@ -0,0 +1 @@
1
+ This exercise should have no metadata.yml file.
@@ -13,6 +13,14 @@ module Trackler
13
13
  !!description && !!metadata
14
14
  end
15
15
 
16
+ def deprecated?
17
+ @deprecated ||= File.exists?(common_metadata_path(deprecation_indicator_path))
18
+ end
19
+
20
+ def active?
21
+ exists? && !deprecated?
22
+ end
23
+
16
24
  def name
17
25
  slug.split('-').map(&:capitalize).join(' ')
18
26
  end
@@ -89,6 +97,10 @@ module Trackler
89
97
  "exercises/%s/description.md" % slug
90
98
  end
91
99
 
100
+ def deprecation_indicator_path
101
+ "exercises/%s/.deprecated" % slug
102
+ end
103
+
92
104
  def repo_url(path)
93
105
  "https://github.com/exercism/x-common/blob/master/#{path}" unless path.nil?
94
106
  end
@@ -3,15 +3,13 @@ module Trackler
3
3
  class Problems
4
4
  include Enumerable
5
5
 
6
- SLUG_PATTERN = Regexp.new(".*\/exercises\/([^\/]*)\/")
7
-
8
6
  attr_reader :root
9
7
  def initialize(root)
10
8
  @root = root
11
9
  end
12
10
 
13
11
  def each
14
- all.each do |problem|
12
+ active.each do |problem|
15
13
  yield problem
16
14
  end
17
15
  end
@@ -27,18 +25,16 @@ module Trackler
27
25
 
28
26
  private
29
27
 
30
- def all
31
- @all ||= dirs.reject { |problem| deprecated?(problem.slug) }
28
+ def active
29
+ @active ||= all.select(&:active?)
32
30
  end
33
31
 
34
- def dirs
35
- @exercise_ids ||= Dir["%s/common/exercises/*/" % root].sort.map { |f|
36
- Problem.new(f[SLUG_PATTERN, 1], root)
37
- }
32
+ def all
33
+ @all_problems ||= exercise_slugs.map { |slug| Problem.new(slug, root) }
38
34
  end
39
35
 
40
- def deprecated?(slug)
41
- File.exist?(File.join(root, "common", "exercises", slug, ".deprecated"))
36
+ def exercise_slugs
37
+ Dir["%s/common/exercises/*/" % root].map { |path| File.basename(path) }.sort
42
38
  end
43
39
 
44
40
  def by_slug
@@ -47,7 +43,7 @@ module Trackler
47
43
 
48
44
  def problem_map
49
45
  hash = Hash.new { |_, k| Problem.new(k, root) }
50
- all.each do |problem|
46
+ active.each do |problem|
51
47
  hash[problem.slug] = problem
52
48
  end
53
49
  hash
@@ -1,3 +1,3 @@
1
1
  module Trackler
2
- VERSION = "2.0.3.0"
2
+ VERSION = "2.0.3.1"
3
3
  end
@@ -1,5 +1,7 @@
1
1
  # xBash
2
2
 
3
+ [![Gitter](https://badges.gitter.im/exercism/xbash.svg)](https://gitter.im/exercism/xbash?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
4
+
3
5
  Exercism Exercises in Bash
4
6
 
5
7
  ## Contributing Guide
@@ -172,7 +172,7 @@
172
172
  "control-flow (if-else statements)"
173
173
  ]
174
174
  }, {
175
- "difficulty": 1,
175
+ "difficulty": 2,
176
176
  "slug": "clock",
177
177
  "topics": [
178
178
  "control-flow (if-statements)",
@@ -180,7 +180,14 @@
180
180
  "text formatting",
181
181
  "preprocessor (x-macros in test)"
182
182
  ]
183
- }, {
183
+ }, {
184
+ "difficulty": 2,
185
+ "slug": "sieve",
186
+ "topics": [
187
+ "control-flow (if-statements)",
188
+ "memory management"
189
+ ]
190
+ }, {
184
191
  "difficulty": 2,
185
192
  "slug": "series",
186
193
  "topics": [
@@ -0,0 +1,15 @@
1
+ CFLAGS = -std=c99
2
+ CFLAGS += -Wall
3
+ CFLAGS += -Wextra
4
+ CFLAGS += -pedantic
5
+ CFLAGS += -Werror
6
+
7
+ test: tests.out
8
+ @./tests.out
9
+
10
+ clean:
11
+ rm -f *.o *.out
12
+
13
+ tests.out: test/test_sieve.c src/sieve.c src/sieve.h
14
+ @echo Compiling $@
15
+ @cc $(CFLAGS) src/sieve.c test/vendor/unity.c test/test_sieve.c -o tests.out -lm
@@ -0,0 +1,50 @@
1
+ #include <string.h>
2
+ #include <stdlib.h>
3
+ #include <math.h>
4
+ #include "sieve.h"
5
+
6
+ unsigned int sieve(const unsigned int limit, primesArray_t primes)
7
+ {
8
+ unsigned int numberOfPrimes = 0;
9
+ unsigned char *numberIsPrime;
10
+
11
+ // clear the results
12
+ memset(primes, 0, sizeof(*primes));
13
+
14
+ if (limit > 1) {
15
+ //allocate 1 more than limit for convenience so the number and the index are same
16
+ numberIsPrime = malloc(limit + 1);
17
+ memset(numberIsPrime, 1, limit + 1);
18
+
19
+ unsigned int maxFactor = sqrt(limit) + 1;
20
+
21
+ // mark 0 and 1 as not prime
22
+ for (unsigned int i = 0; i < 2; i++) {
23
+ numberIsPrime[i] = 0;
24
+ }
25
+
26
+ // mark the remaining numbers in the array according to the algo.
27
+ for (unsigned int index = 2; index < maxFactor;) {
28
+ // mark all of multiples that can't be prime
29
+ for (unsigned int nonPrimeIndex = (2 * index);
30
+ nonPrimeIndex < (limit + 1); nonPrimeIndex += index) {
31
+ numberIsPrime[nonPrimeIndex] = 0;
32
+ }
33
+
34
+ // adjust the index
35
+ do {
36
+ index++;
37
+ if (numberIsPrime[index]) {
38
+ break;
39
+ }
40
+ } while (index <= maxFactor);
41
+ }
42
+ // collect and count the primes found
43
+ for (unsigned int i = 1; i < limit + 1; i++) {
44
+ if (numberIsPrime[i]) {
45
+ primes[numberOfPrimes++] = i;
46
+ }
47
+ }
48
+ }
49
+ return numberOfPrimes;
50
+ }
@@ -0,0 +1,10 @@
1
+ #ifndef _SIEVE_H
2
+ #define _SIEVE_H
3
+
4
+ #define MAX_LIMIT_TESTED (1000)
5
+
6
+ typedef unsigned int primesArray_t[MAX_LIMIT_TESTED];
7
+
8
+ unsigned int sieve(const unsigned int limit, primesArray_t primes);
9
+
10
+ #endif
@@ -0,0 +1,113 @@
1
+ #include <string.h>
2
+ #include "vendor/unity.h"
3
+ #include "../src/sieve.h"
4
+
5
+ static primesArray_t result_array;
6
+
7
+ void test_no_primes_under_two(void)
8
+ {
9
+ const unsigned int limit = 1;
10
+ const primesArray_t expected_prime_array = { 0 };
11
+ const unsigned int expected_prime_count = 0;
12
+ unsigned int result_prime_count;
13
+
14
+ memset(result_array, 0, sizeof(result_array));
15
+
16
+ result_prime_count = sieve(limit, result_array);
17
+ TEST_ASSERT_EQUAL(expected_prime_count, result_prime_count);
18
+ TEST_ASSERT_EQUAL(0,
19
+ memcmp(expected_prime_array, result_array,
20
+ sizeof(result_array)));
21
+ }
22
+
23
+ void test_find_first_prime(void)
24
+ {
25
+ const unsigned int limit = 2;
26
+ const primesArray_t expected_prime_array = { 2 };
27
+ const unsigned int expected_prime_count = 1;
28
+ unsigned int result_prime_count;
29
+
30
+ memset(result_array, 0, sizeof(result_array));
31
+
32
+ result_prime_count = sieve(limit, result_array);
33
+ TEST_ASSERT_EQUAL(expected_prime_count, result_prime_count);
34
+ TEST_ASSERT_EQUAL(0,
35
+ memcmp(expected_prime_array, result_array,
36
+ sizeof(expected_prime_array)));
37
+ }
38
+
39
+ void test_find_primes_up_to_10(void)
40
+ {
41
+ const unsigned int limit = 10;
42
+ const primesArray_t expected_prime_array = { 2, 3, 5, 7 };
43
+ const unsigned int expected_prime_count = 4;
44
+ unsigned int result_prime_count;
45
+
46
+ memset(result_array, 0, sizeof(result_array));
47
+
48
+ result_prime_count = sieve(limit, result_array);
49
+ TEST_ASSERT_EQUAL(expected_prime_count, result_prime_count);
50
+ TEST_ASSERT_EQUAL(0,
51
+ memcmp(expected_prime_array, result_array,
52
+ sizeof(expected_prime_array)));
53
+ }
54
+
55
+ void test_limit_is_prime(void)
56
+ {
57
+ const unsigned int limit = 13;
58
+ const primesArray_t expected_prime_array = { 2, 3, 5, 7, 11, 13 };
59
+ const unsigned int expected_prime_count = 6;
60
+ unsigned int result_prime_count;
61
+
62
+ memset(result_array, 0, sizeof(result_array));
63
+
64
+ result_prime_count = sieve(limit, result_array);
65
+ TEST_ASSERT_EQUAL(expected_prime_count, result_prime_count);
66
+ TEST_ASSERT_EQUAL(0,
67
+ memcmp(expected_prime_array, result_array,
68
+ sizeof(expected_prime_array)));
69
+ }
70
+
71
+ void test_find_primes_up_to_1000(void)
72
+ {
73
+ const unsigned int limit = 1000;
74
+ const primesArray_t expected_prime_array = {
75
+ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
76
+ 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
77
+ 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193,
78
+ 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269,
79
+ 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
80
+ 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431,
81
+ 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
82
+ 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599,
83
+ 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673,
84
+ 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761,
85
+ 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857,
86
+ 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947,
87
+ 953, 967, 971, 977, 983, 991, 997
88
+ };
89
+ const unsigned int expected_prime_count = 168;
90
+ unsigned int result_prime_count;
91
+
92
+ memset(result_array, 0, sizeof(result_array));
93
+
94
+ result_prime_count = sieve(limit, result_array);
95
+ TEST_ASSERT_EQUAL(expected_prime_count, result_prime_count);
96
+ TEST_ASSERT_EQUAL(0,
97
+ memcmp(expected_prime_array, result_array,
98
+ sizeof(expected_prime_array)));
99
+ }
100
+
101
+ int main(void)
102
+ {
103
+ UnityBegin("test/test_sum_of_multiples.c");
104
+
105
+ RUN_TEST(test_no_primes_under_two);
106
+ RUN_TEST(test_find_first_prime);
107
+ RUN_TEST(test_find_primes_up_to_10);
108
+ RUN_TEST(test_limit_is_prime);
109
+ RUN_TEST(test_find_primes_up_to_1000);
110
+
111
+ UnityEnd();
112
+ return 0;
113
+ }
@@ -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
+ //-----------------------------------------------