ceedling 0.20.3 → 0.21.0

data/vendor/cmock/vendor/unity/test/tests/testparameterized.c

@@ -8,7 +8,7 @@
 #include <stdio.h>
 #include "unity.h"
 
-int putcharSpy(int c) {return putchar(c);} // include passthrough for linking tests
+void putcharSpy(int c) { (void)putchar(c);} // include passthrough for linking tests
 
 #define TEST_CASE(...)
 

data/vendor/cmock/vendor/unity/test/tests/testunity.c

@@ -8,8 +8,6 @@
 #include "unity.h"
 #include <string.h>
 
-int putcharSpy(int c);
-
 // Dividing by these constants produces +/- infinity.
 // The rationale is given in UnityAssertFloatIsInf's body.
 #ifndef UNITY_EXCLUDE_FLOAT
@@ -46,8 +44,8 @@ static const _UD d_zero = 0.0;
       UNITY_OUTPUT_CHAR('\n');                                                 \
     }
 
-int SetToOneToFailInTearDown;
-int SetToOneMeanWeAlreadyCheckedThisGuy;
+static int SetToOneToFailInTearDown;
+static int SetToOneMeanWeAlreadyCheckedThisGuy;
 
 void setUp(void)
 {
@@ -1372,7 +1370,7 @@ void testNotEqualString4(void)
 void testNotEqualStringLen4(void)
 {
     EXPECT_ABORT_BEGIN
-    TEST_ASSERT_EQUAL_STRING_LEN("bar\r", "bar\n", 4);
+    TEST_ASSERT_EQUAL_STRING_LEN("\r\x16", "bar\n", 4);
     VERIFY_FAILS_END
 }
 
@@ -1392,6 +1390,13 @@ void testNotEqualString_ExpectedStringIsNull(void)
     VERIFY_FAILS_END
 }
 
+void testNotEqualStringLen_ExpectedStringIsNull(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_EQUAL_STRING_LEN(NULL, "bar", 1);
+    VERIFY_FAILS_END
+}
+
 void testNotEqualString_ActualStringIsNull(void)
 {
     EXPECT_ABORT_BEGIN
@@ -1399,6 +1404,13 @@ void testNotEqualString_ActualStringIsNull(void)
     VERIFY_FAILS_END
 }
 
+void testNotEqualStringLen_ActualStringIsNull(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_EQUAL_STRING_LEN("foo", NULL, 1);
+    VERIFY_FAILS_END
+}
+
 void testEqualStringArrays(void)
 {
     const char *testStrings[] = { "foo", "boo", "woo", "moo" };
@@ -1478,6 +1490,16 @@ void testEqualStringArrayIfBothNulls(void)
     TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4);
 }
 
+void testNotEqualStringArrayLengthZero(void)
+{
+    const char *testStrings[] = {NULL};
+    const char **expStrings = NULL;
+
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 0);
+    VERIFY_FAILS_END
+}
+
 void testEqualMemory(void)
 {
     const char *testString = "whatever";
@@ -1518,6 +1540,13 @@ void testNotEqualMemory4(void)
     VERIFY_FAILS_END
 }
 
+void testNotEqualMemoryLengthZero(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 0);
+    VERIFY_FAILS_END
+}
+
 void testEqualIntArrays(void)
 {
     int p0[] = {1, 8, 987, -2};
@@ -1530,6 +1559,7 @@ void testEqualIntArrays(void)
     TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4);
     TEST_ASSERT_EQUAL_INT_ARRAY(p0, p2, 3);
     TEST_ASSERT_EQUAL_INT_ARRAY(p0, p3, 1);
+    TEST_ASSERT_EQUAL_INT_ARRAY(NULL, NULL, 1);
 }
 
 void testNotEqualIntArraysNullExpected(void)
@@ -1582,6 +1612,16 @@ void testNotEqualIntArrays3(void)
     VERIFY_FAILS_END
 }
 
+void testNotEqualIntArraysLengthZero(void)
+{
+    _UU32 p0[1] = {1};
+    _UU32 p1[1] = {1};
+
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 0);
+    VERIFY_FAILS_END
+}
+
 void testEqualPtrArrays(void)
 {
     char A = 1;
@@ -2207,7 +2247,7 @@ char* getBufferPutcharSpy(void)
 #endif
 }
 
-int putcharSpy(int c)
+void putcharSpy(int c)
 {
 #ifdef USING_OUTPUT_SPY
     if (putcharSpyEnabled)
@@ -2217,7 +2257,19 @@ int putcharSpy(int c)
     } else
         c = putchar(c);
 #endif
-    return c;
+}
+
+void testFailureCountIncrementsAndIsReturnedAtEnd(void)
+{
+    Unity.CurrentTestFailed = 1;
+    startPutcharSpy(); // Suppress output
+    UnityConcludeTest();
+    TEST_ASSERT_EQUAL(1, Unity.TestFailures);
+
+    int failures = UnityEnd();
+    Unity.TestFailures--;
+    endPutcharSpy();
+    TEST_ASSERT_EQUAL(1, failures);
 }
 
 #define TEST_ASSERT_EQUAL_PRINT_NUMBERS(expected, actual) {             \
@@ -3007,6 +3059,7 @@ void testEqualFloatArrays(void)
     TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4);
     TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3);
     TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1);
+    TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1);
 #endif
 }
 
@@ -3150,6 +3203,20 @@ void testNotEqualFloatArraysInf(void)
 #endif
 }
 
+void testNotEqualFloatArraysLengthZero(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    float p0[1] = {0.0f};
+    float p1[1] = {0.0f};
+
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0);
+    VERIFY_FAILS_END
+#endif
+}
+
 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DOUBLE SUPPORT ==================
 
 void testDoublesWithinDelta(void)
@@ -3523,6 +3590,7 @@ void testEqualDoubleArrays(void)
     TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
     TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3);
     TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1);
+    TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1);
 #endif
 }
 
@@ -3666,6 +3734,22 @@ void testNotEqualDoubleArraysInf(void)
 #endif
 }
 
+void testNotEqualDoubleArraysLengthZero(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    double p0[1] = {0.0};
+    double p1[1] = {0.0};
+
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0);
+    VERIFY_FAILS_END
+#endif
+}
+
+// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DETAIL SUPPORT ==================
+
 void testThatDetailsCanBeHandleOneDetail(void)
 {
 #ifdef UNITY_EXCLUDE_DETAILS
@@ -3679,6 +3763,19 @@ void testThatDetailsCanBeHandleOneDetail(void)
 #endif
 }
 
+void testThatDetailsCanHandleTestFail(void)
+{
+#ifdef UNITY_EXCLUDE_DETAILS
+    TEST_IGNORE();
+#else
+    UNITY_SET_DETAILS("Detail1","Detail2");
+
+    EXPECT_ABORT_BEGIN
+    TEST_FAIL_MESSAGE("Should Fail And Say Detail1 and Detail2");
+    VERIFY_FAILS_END
+#endif
+}
+
 void testThatDetailsCanBeHandleTwoDetails(void)
 {
 #ifdef UNITY_EXCLUDE_DETAILS

data/vendor/deep_merge/README

@@ -1,94 +1,94 @@
-DeepMerge Overview
-==================
-
-Deep Merge is a simple set of utility functions for Hash. It permits
-you to merge elements inside a hash together recursively. The manner
-by which it does this is somewhat arbitrary (since there is no defining 
-standard for this) but it should end up being pretty intuitive and do what
-you expect.
-
-You can learn a lot more about this by reading the test file. It's pretty
-well documented and has many examples of various merges from very simple
-to pretty complex.
-
-The primary need that caused me to write this library is the merging of elements
-coming from HTTP parameters and related stored parameters in session. This lets
-a user build up a set of parameters over time, modifying individual items.
-
-Deep Merge Core Documentation
-=============================
- There are three key methods that are added to Hash when you require deep_merge:
- 
- deep_merge!(new_hash[, opts]) -- merges and new_hash wins unmergeable situations
- deep_merge(new_hash[, opts]) -- merges and "self" hash wins unmergeable situations
- ko_deep_merge!(new_hash[, opts]) -- same as deep_merge! but "--" provides "knockout" functions
- 
- deep_merge! method permits merging of arbitrary child elements. The two top level
- elements must be hashes. These hashes can contain unlimited (to stack limit) levels
- of child elements. These child elements to not have to be of the same types.
- Where child elements are of the same type, deep_merge will attempt to merge them together.
- Where child elements are not of the same type, deep_merge will skip or optionally overwrite
- the destination element with the contents of the source element at that level.
- So if you have two hashes like this:
-   source = {:x => [1,2,3], :y => 2}
-   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
-   dest.deep_merge!(source)
-   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
- By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
- To avoid this, use "deep_merge" (no bang/exclamation mark)
- 
- Options:
-   Options are specified in the last parameter passed, which should be in hash format:
-   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
-   :preserve_unmergeables  DEFAULT: false
-      Set to true to skip any unmergeable elements from source
-   :knockout_prefix        DEFAULT: nil
-      Set to string value to signify prefix which deletes elements from existing element
-   :sort_merged_arrays     DEFAULT: false
-      Set to true to sort all arrays that are merged together
-   :unpack_arrays          DEFAULT: nil
-      Set to string value to run "Array::join" then "String::split" against all arrays
-   :merge_debug            DEFAULT: false
-      Set to true to get console output of merge process for debugging
-
- Selected Options Details:
- :knockout_prefix => The purpose of this is to provide a way to remove elements 
-   from existing Hash by specifying them in a special way in incoming hash
-    source = {:x => ['--1', '2']}
-    dest   = {:x => ['1', '3']}
-    dest.ko_deep_merge!(source)
-    Results: {:x => ['2','3']}
-   Additionally, if the knockout_prefix is passed alone as a string, it will cause
-   the entire element to be removed:
-    source = {:x => '--'}
-    dest   = {:x => [1,2,3]}
-    dest.ko_deep_merge!(source)
-    Results: {:x => ""}
- :unpack_arrays => The purpose of this is to permit compound elements to be passed
-   in as strings and to be converted into discrete array elements
-   irsource = {:x => ['1,2,3', '4']}
-   dest   = {:x => ['5','6','7,8']}
-   dest.deep_merge!(source, {:unpack_arrays => ','})
-   Results: {:x => ['1','2','3','4','5','6','7','8'}
-   Why: If receiving data from an HTML form, this makes it easy for a checkbox 
-    to pass multiple values from within a single HTML element
- 
- There are many tests for this library - and you can learn more about the features
- and usages of deep_merge! by just browsing the test examples
-
-
-Simple Example Code
-===================
-
-require 'deep_merge'
-x = {:x => [3,4,5]}
-y = {:x => [1,2,3]}
-y.deep_merge!(x)
-# results: y = {:x => [1,2,3,4,5]}
-
-Availablility
-=============
-SVN Repo here:  http://trac.misuse.org/science/wiki/DeepMerge
-Contact author: http://www.misuse.org/science
-
-Copyright (c) 2008 Steve Midgley, released under the MIT license
+DeepMerge Overview
+==================
+
+Deep Merge is a simple set of utility functions for Hash. It permits
+you to merge elements inside a hash together recursively. The manner
+by which it does this is somewhat arbitrary (since there is no defining 
+standard for this) but it should end up being pretty intuitive and do what
+you expect.
+
+You can learn a lot more about this by reading the test file. It's pretty
+well documented and has many examples of various merges from very simple
+to pretty complex.
+
+The primary need that caused me to write this library is the merging of elements
+coming from HTTP parameters and related stored parameters in session. This lets
+a user build up a set of parameters over time, modifying individual items.
+
+Deep Merge Core Documentation
+=============================
+ There are three key methods that are added to Hash when you require deep_merge:
+ 
+ deep_merge!(new_hash[, opts]) -- merges and new_hash wins unmergeable situations
+ deep_merge(new_hash[, opts]) -- merges and "self" hash wins unmergeable situations
+ ko_deep_merge!(new_hash[, opts]) -- same as deep_merge! but "--" provides "knockout" functions
+ 
+ deep_merge! method permits merging of arbitrary child elements. The two top level
+ elements must be hashes. These hashes can contain unlimited (to stack limit) levels
+ of child elements. These child elements to not have to be of the same types.
+ Where child elements are of the same type, deep_merge will attempt to merge them together.
+ Where child elements are not of the same type, deep_merge will skip or optionally overwrite
+ the destination element with the contents of the source element at that level.
+ So if you have two hashes like this:
+   source = {:x => [1,2,3], :y => 2}
+   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+   dest.deep_merge!(source)
+   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+ By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
+ To avoid this, use "deep_merge" (no bang/exclamation mark)
+ 
+ Options:
+   Options are specified in the last parameter passed, which should be in hash format:
+   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
+   :preserve_unmergeables  DEFAULT: false
+      Set to true to skip any unmergeable elements from source
+   :knockout_prefix        DEFAULT: nil
+      Set to string value to signify prefix which deletes elements from existing element
+   :sort_merged_arrays     DEFAULT: false
+      Set to true to sort all arrays that are merged together
+   :unpack_arrays          DEFAULT: nil
+      Set to string value to run "Array::join" then "String::split" against all arrays
+   :merge_debug            DEFAULT: false
+      Set to true to get console output of merge process for debugging
+
+ Selected Options Details:
+ :knockout_prefix => The purpose of this is to provide a way to remove elements 
+   from existing Hash by specifying them in a special way in incoming hash
+    source = {:x => ['--1', '2']}
+    dest   = {:x => ['1', '3']}
+    dest.ko_deep_merge!(source)
+    Results: {:x => ['2','3']}
+   Additionally, if the knockout_prefix is passed alone as a string, it will cause
+   the entire element to be removed:
+    source = {:x => '--'}
+    dest   = {:x => [1,2,3]}
+    dest.ko_deep_merge!(source)
+    Results: {:x => ""}
+ :unpack_arrays => The purpose of this is to permit compound elements to be passed
+   in as strings and to be converted into discrete array elements
+   irsource = {:x => ['1,2,3', '4']}
+   dest   = {:x => ['5','6','7,8']}
+   dest.deep_merge!(source, {:unpack_arrays => ','})
+   Results: {:x => ['1','2','3','4','5','6','7','8'}
+   Why: If receiving data from an HTML form, this makes it easy for a checkbox 
+    to pass multiple values from within a single HTML element
+ 
+ There are many tests for this library - and you can learn more about the features
+ and usages of deep_merge! by just browsing the test examples
+
+
+Simple Example Code
+===================
+
+require 'deep_merge'
+x = {:x => [3,4,5]}
+y = {:x => [1,2,3]}
+y.deep_merge!(x)
+# results: y = {:x => [1,2,3,4,5]}
+
+Availablility
+=============
+SVN Repo here:  http://trac.misuse.org/science/wiki/DeepMerge
+Contact author: http://www.misuse.org/science
+
+Copyright (c) 2008 Steve Midgley, released under the MIT license

data/vendor/deep_merge/Rakefile

@@ -1,28 +1,28 @@
-require 'rubygems'
-require 'lib/deep_merge'
-Gem::manage_gems
-require 'rake/gempackagetask'
-
-spec = Gem::Specification.new do |s|
-    s.platform  =   Gem::Platform::RUBY
-    s.name      =   "deep_merge"
-    s.version   =   DeepMerge::VERSION
-    s.author    =   "Steve Midgley"
-    s.email     =   "public@misuse.org"
-    s.summary   =   "Permits recursive/deep merges of arrays and hashes."
-    s.files     =   FileList['lib/*.rb', 'test/*'].to_a
-    s.require_path  =   "lib"
-    s.autorequire   =   "deep_merge"
-    s.test_files = Dir.glob('tests/*.rb')
-    s.has_rdoc  =   true
-    s.extra_rdoc_files  =   ["README"]
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_tar = true
-end
-
-task :default => "pkg/#{spec.name}-#{spec.version}.gem" do
-    puts "generated latest version"
-end
-
+require 'rubygems'
+require 'lib/deep_merge'
+Gem::manage_gems
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+    s.platform  =   Gem::Platform::RUBY
+    s.name      =   "deep_merge"
+    s.version   =   DeepMerge::VERSION
+    s.author    =   "Steve Midgley"
+    s.email     =   "public@misuse.org"
+    s.summary   =   "Permits recursive/deep merges of arrays and hashes."
+    s.files     =   FileList['lib/*.rb', 'test/*'].to_a
+    s.require_path  =   "lib"
+    s.autorequire   =   "deep_merge"
+    s.test_files = Dir.glob('tests/*.rb')
+    s.has_rdoc  =   true
+    s.extra_rdoc_files  =   ["README"]
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+end
+
+task :default => "pkg/#{spec.name}-#{spec.version}.gem" do
+    puts "generated latest version"
+end
+