ceedling 0.13.0 → 0.15.0

data/vendor/unity/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org/"
+
+gem "rake"
+gem "test-unit", "2.4.3"

data/vendor/unity/auto/generate_test_runner.rb

@@ -176,21 +176,24 @@ class UnityTestRunnerGenerator
         output.puts("  GlobalOrderError = NULL;") 
       end
       mocks.each do |mock|
-        output.puts("  #{mock}_Init();")
+        mock_clean = mock.gsub(/(?:-|\s+)/, "_")
+        output.puts("  #{mock_clean}_Init();")
       end
       output.puts("}\n")
 
       output.puts("static void CMock_Verify(void)")
       output.puts("{")
       mocks.each do |mock|
-        output.puts("  #{mock}_Verify();")
+        mock_clean = mock.gsub(/(?:-|\s+)/, "_")
+        output.puts("  #{mock_clean}_Verify();")
       end
       output.puts("}\n")
 
       output.puts("static void CMock_Destroy(void)")
       output.puts("{")
       mocks.each do |mock|
-        output.puts("  #{mock}_Destroy();")
+        mock_clean = mock.gsub(/(?:-|\s+)/, "_")
+        output.puts("  #{mock_clean}_Destroy();")
       end
       output.puts("}\n")
     end

data/vendor/unity/examples/makefile

@@ -32,8 +32,8 @@ default:
 #	ruby auto/generate_test_runner.rb test/TestProductionCode2.c test/no_ruby/TestProductionCode2_Runner.c
 	$(C_COMPILER) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES1) -o $(TARGET1)
 	$(C_COMPILER) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES2) -o $(TARGET2)
-	$(TARGET1)
-	$(TARGET2)
+	./$(TARGET1)
+	./$(TARGET2)
 
 clean:
 	$(CLEANUP)

data/vendor/unity/examples/rakefile.rb

@@ -5,13 +5,24 @@ require 'rake/clean'
 require 'rake/testtask'
 require HERE+'rakefile_helper'
 
+TEMP_DIRS = [
+	File.join(HERE, 'build')
+]
+
+TEMP_DIRS.each do |dir|
+  directory(dir)
+  CLOBBER.include(dir)
+end
+
+task :prepare_for_tests => TEMP_DIRS
+
 include RakefileHelpers
 
 # Load default configuration, for now
-DEFAULT_CONFIG_FILE = 'gcc.yml'
+DEFAULT_CONFIG_FILE = 'gcc_32.yml'
 configure_toolchain(DEFAULT_CONFIG_FILE)
 
-task :unit do
+task :unit => [:prepare_for_tests] do
   run_tests get_unit_test_files
 end
 

data/vendor/unity/extras/fixture/rakefile.rb

@@ -14,7 +14,7 @@ require HERE + 'rakefile_helper'
 include RakefileHelpers
 
 # Load default configuration, for now
-DEFAULT_CONFIG_FILE = 'gcc.yml'
+DEFAULT_CONFIG_FILE = 'gcc_32.yml'
 configure_toolchain(DEFAULT_CONFIG_FILE)
 
 task :unit do

data/vendor/unity/extras/fixture/rakefile_helper.rb

@@ -87,7 +87,7 @@ module RakefileHelpers
     return {:command => command, :options => options, :includes => includes}
   end
   
-  def link(exe_name, obj_list)
+  def link_it(exe_name, obj_list)
     linker = build_linker_fields
     cmd_str = "#{linker[:command]}#{linker[:options]}#{linker[:includes]} " +
       (obj_list.map{|obj|"#{$cfg['linker']['object_files']['path']}#{obj} "}).join +
@@ -148,7 +148,8 @@ module RakefileHelpers
     # Get a list of all source files needed
     src_files  = Dir[HERE+'src/*.c']
     src_files += Dir[HERE+'test/*.c']
-    src_files << '../../src/Unity.c'
+    src_files += Dir[HERE+'test/main/*.c']
+    src_files << '../../src/unity.c'
     
     # Build object files
     src_files.each { |f| compile(f, test_defines) }
@@ -156,7 +157,7 @@ module RakefileHelpers
     
     # Link the test executable
     test_base = "framework_test"
-    link(test_base, obj_list)
+    link_it(test_base, obj_list)
       
     # Execute unit test and generate results file
     simulator = build_simulator_fields

data/vendor/unity/extras/fixture/src/unity_fixture.c

@@ -5,9 +5,9 @@
     [Released under MIT License. Please refer to license.txt for details]
 ========================================== */
 
+#include <string.h>
 #include "unity_fixture.h"
 #include "unity_internals.h"
-#include <string.h>
 
 UNITY_FIXTURE_T UnityFixture;
 
@@ -107,20 +107,20 @@ void UnityTestRunner(unityfunction* setup,
             UnityPointer_UndoAllSets();
             if (!Unity.CurrentTestFailed)
                 UnityMalloc_EndTest();
-            UnityConcludeFixtureTest();
-        }
-        else
-        {
-            //aborting - jwg - di i need these for the other TEST_PROTECTS?
         }
+        UnityConcludeFixtureTest();
     }
 }
 
-void UnityIgnoreTest()
+void UnityIgnoreTest(const char * printableName)
 {
     Unity.NumberOfTests++;
     Unity.CurrentTestIgnored = 1;
-    UNITY_OUTPUT_CHAR('!');
+    if (!UnityFixture.Verbose)
+        UNITY_OUTPUT_CHAR('!');
+    else
+        UnityPrint(printableName);
+    UnityConcludeFixtureTest();
 }
 
 
@@ -164,8 +164,8 @@ void UnityMalloc_MakeMallocFailAfterCount(int countdown)
 
 typedef struct GuardBytes
 {
-    int size;
-    char guard[sizeof(int)];
+    size_t size;
+    char guard[sizeof(size_t)];
 } Guard;
 
 
@@ -254,7 +254,7 @@ void* unity_realloc(void * oldMem, size_t size)
         return oldMem;
 
     newMem = unity_malloc(size);
-    memcpy(newMem, oldMem, size);
+    memcpy(newMem, oldMem, guard->size);
     unity_free(oldMem);
     return newMem;
 }
@@ -360,6 +360,10 @@ void UnityConcludeFixtureTest()
 {
     if (Unity.CurrentTestIgnored)
     {
+        if (UnityFixture.Verbose)
+        {
+            UNITY_OUTPUT_CHAR('\n');
+        }
         Unity.TestIgnores++;
     }
     else if (!Unity.CurrentTestFailed)
@@ -378,4 +382,3 @@ void UnityConcludeFixtureTest()
     Unity.CurrentTestFailed = 0;
     Unity.CurrentTestIgnored = 0;
 }
-

data/vendor/unity/extras/fixture/src/unity_fixture.h

@@ -41,7 +41,7 @@ int UnityMain(int argc, char* argv[], void (*runAllTests)());
     void TEST_##group##_##name##_();\
     void TEST_##group##_##name##_run()\
     {\
-        UnityIgnoreTest();\
+        UnityIgnoreTest("IGNORE_TEST(" #group ", " #name ")");\
     }\
     void  TEST_##group##_##name##_()
 
@@ -49,8 +49,8 @@ int UnityMain(int argc, char* argv[], void (*runAllTests)());
     void TEST_##group##_##name##_run()
 
 #define RUN_TEST_CASE(group, name) \
-        DECLARE_TEST_CASE(group, name);\
-    TEST_##group##_##name##_run();
+    { DECLARE_TEST_CASE(group, name);\
+      TEST_##group##_##name##_run(); }
 
 //This goes at the bottom of each test file or in a separate c file
 #define TEST_GROUP_RUNNER(group)\
@@ -63,8 +63,8 @@ int UnityMain(int argc, char* argv[], void (*runAllTests)());
 
 //Call this from main
 #define RUN_TEST_GROUP(group)\
-    void TEST_##group##_GROUP_RUNNER();\
-    TEST_##group##_GROUP_RUNNER();
+    { void TEST_##group##_GROUP_RUNNER();\
+      TEST_##group##_GROUP_RUNNER(); }
 
 //CppUTest Compatibility Macros
 #define UT_PTR_SET(ptr, newPointerValue)               UnityPointer_Set((void**)&ptr, (void*)newPointerValue)

data/vendor/unity/extras/fixture/src/unity_fixture_internals.h

@@ -25,7 +25,7 @@ void UnityTestRunner(unityfunction * setup,
         const char * name,
         const char * file, int line);
 
-void UnityIgnoreTest();
+void UnityIgnoreTest(const char * printableName);
 void UnityMalloc_StartTest();
 void UnityMalloc_EndTest();
 int UnityFailureCount();

data/vendor/unity/extras/fixture/test/unity_fixture_Test.c

@@ -49,10 +49,12 @@ TEST(UnityFixture, PointerSetting)
 
 TEST(UnityFixture, ForceMallocFail)
 {
+    void* m;
+    void* mfails;
     UnityMalloc_MakeMallocFailAfterCount(1);
-    void* m = malloc(10);
+    m = malloc(10);
     CHECK(m);
-    void* mfails = malloc(10);
+    mfails = malloc(10);
     TEST_ASSERT_POINTERS_EQUAL(0, mfails);
     free(m);
 }
@@ -76,8 +78,9 @@ TEST(UnityFixture, ReallocSameIsUnchanged)
 TEST(UnityFixture, ReallocLargerNeeded)
 {
     void* m1 = malloc(10);
+    void* m2;
     strcpy((char*)m1, "123456789");
-    void* m2 = realloc(m1, 15);
+    m2 = realloc(m1, 15);
     CHECK(m1 != m2);
     STRCMP_EQUAL("123456789", m2);
     free(m2);

data/vendor/unity/makefile

@@ -20,7 +20,7 @@ SYMBOLS=-DTEST -DUNITY_SUPPORT_64
 ifeq ($(OS),Windows_NT)
 	CLEANUP = del /F /Q build\* && del /F /Q $(TARGET)
 else
-	CLEANUP = rm -f build/*.o ; rm -f $(TARGET)
+	CLEANUP = rm -f build/*.o ; rm -f $(TARGET) ; mkdir -p build
 endif
 
 all: clean default
@@ -28,7 +28,7 @@ all: clean default
 default:
 	ruby auto/generate_test_runner.rb test/testunity.c build/testunity_Runner.c
 	$(C_COMPILER) $(INC_DIRS) $(SYMBOLS) $(SRC_FILES) $(OUT_FILE)
-	$(TARGET)
+	./$(TARGET)
 
 clean:
 	$(CLEANUP)

data/vendor/unity/src/unity.c

@@ -28,6 +28,18 @@ const char* UnityStrDelta    = " Values Not Within Delta ";
 const char* UnityStrPointless= " You Asked Me To Compare Nothing, Which Was Pointless.";
 const char* UnityStrNullPointerForExpected= " Expected pointer to be NULL";
 const char* UnityStrNullPointerForActual  = " Actual pointer was NULL";
+const char* UnityStrInf      = "Infinity";
+const char* UnityStrNegInf   = "Negative Infinity";
+const char* UnityStrNaN      = "NaN";
+
+#ifndef UNITY_EXCLUDE_FLOAT
+// Dividing by these constants produces +/- infinity.
+// The rationale is given in UnityAssertFloatIsInf's body.
+static const _UF f_zero = 0.0f;
+#ifndef UNITY_EXCLUDE_DOUBLE
+static const _UD d_zero = 0.0;
+#endif
+#endif
 
 // compiler-generic print formatting masks
 const _U_UINT UnitySizeMask[] = 
@@ -413,7 +425,10 @@ void UnityAssertEqualIntArray(const _U_SINT* expected,
     if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
         return;
 
-    switch(style)
+    // If style is UNITY_DISPLAY_STYLE_INT, we'll fall into the default case rather than the INT16 or INT32 (etc) case
+    // as UNITY_DISPLAY_STYLE_INT includes a flag for UNITY_DISPLAY_RANGE_AUTO, which the width-specific
+    // variants do not. Therefore remove this flag.
+    switch(style & ~UNITY_DISPLAY_RANGE_AUTO)
     {
         case UNITY_DISPLAY_STYLE_HEX8:
         case UNITY_DISPLAY_STYLE_INT8:
@@ -531,12 +546,14 @@ void UnityAssertEqualFloatArray(const _UF* expected,
     while (elements--)
     {
         diff = *ptr_expected - *ptr_actual;
-        if (diff < 0.0)
-          diff = 0.0 - diff;
+        if (diff < 0.0f)
+          diff = 0.0f - diff;
         tol = UNITY_FLOAT_PRECISION * *ptr_expected;
-        if (tol < 0.0)
-            tol = 0.0 - tol;
-        if (diff > tol)
+        if (tol < 0.0f)
+            tol = 0.0f - tol;
+        
+        //This first part of this condition will catch any NaN or Infinite values
+        if ((diff * 0.0f != 0.0f) || (diff > tol))
         {
             UnityTestResultsFailBegin(lineNumber);
             UnityPrint(UnityStrElement);
@@ -569,16 +586,17 @@ void UnityAssertFloatsWithin(const _UF delta,
 
     UNITY_SKIP_EXECUTION;
   
-    if (diff < 0)
+    if (diff < 0.0f)
     {
         diff = 0.0f - diff;
     }
-    if (pos_delta < 0)
+    if (pos_delta < 0.0f)
     {
         pos_delta = 0.0f - pos_delta;
     }
 
-    if (pos_delta < diff)
+    //This first part of this condition will catch any NaN or Infinite values
+    if ((diff * 0.0f != 0.0f) || (pos_delta < diff))
     {
         UnityTestResultsFailBegin(lineNumber);
 #ifdef UNITY_FLOAT_VERBOSE
@@ -594,6 +612,81 @@ void UnityAssertFloatsWithin(const _UF delta,
     }
 }
 
+//-----------------------------------------------
+void UnityAssertFloatIsInf(const _UF actual,
+                           const char* msg,
+                           const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_SKIP_EXECUTION;
+
+    // In Microsoft Visual C++ Express Edition 2008,
+    //   if ((1.0f / f_zero) != actual)
+    // produces
+    //   error C2124: divide or mod by zero
+    // As a workaround, place 0 into a variable.
+    if ((1.0f / f_zero) != actual)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+#ifdef UNITY_FLOAT_VERBOSE
+        UnityPrint(UnityStrExpected);
+        UnityPrint(UnityStrInf);
+        UnityPrint(UnityStrWas);
+        UnityPrintFloat(actual);
+#else
+        UnityPrint(UnityStrDelta);
+#endif
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
+//-----------------------------------------------
+void UnityAssertFloatIsNegInf(const _UF actual,
+                              const char* msg,
+                              const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_SKIP_EXECUTION;
+
+    // The rationale for not using 1.0f/0.0f is given in UnityAssertFloatIsInf's body.
+    if ((-1.0f / f_zero) != actual)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+#ifdef UNITY_FLOAT_VERBOSE
+        UnityPrint(UnityStrExpected);
+        UnityPrint(UnityStrNegInf);
+        UnityPrint(UnityStrWas);
+        UnityPrintFloat(actual);
+#else
+        UnityPrint(UnityStrDelta);
+#endif
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
+//-----------------------------------------------
+void UnityAssertFloatIsNaN(const _UF actual,
+                           const char* msg,
+                           const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_SKIP_EXECUTION;
+
+    if (actual == actual)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+#ifdef UNITY_FLOAT_VERBOSE
+        UnityPrint(UnityStrExpected);
+        UnityPrint(UnityStrNaN);
+        UnityPrint(UnityStrWas);
+        UnityPrintFloat(actual);
+#else
+        UnityPrint(UnityStrDelta);
+#endif
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
 #endif //not UNITY_EXCLUDE_FLOAT
 
 //-----------------------------------------------
@@ -630,7 +723,9 @@ void UnityAssertEqualDoubleArray(const _UD* expected,
         tol = UNITY_DOUBLE_PRECISION * *ptr_expected;
         if (tol < 0.0)
             tol = 0.0 - tol;
-        if (diff > tol)
+        
+        //This first part of this condition will catch any NaN or Infinite values
+        if ((diff * 0.0 != 0.0) || (diff > tol))
         {
             UnityTestResultsFailBegin(lineNumber);
             UnityPrint(UnityStrElement);
@@ -663,16 +758,17 @@ void UnityAssertDoublesWithin(const _UD delta,
 
     UNITY_SKIP_EXECUTION;
   
-    if (diff < 0)
+    if (diff < 0.0)
     {
-        diff = 0.0f - diff;
+        diff = 0.0 - diff;
     }
-    if (pos_delta < 0)
+    if (pos_delta < 0.0)
     {
-        pos_delta = 0.0f - pos_delta;
+        pos_delta = 0.0 - pos_delta;
     }
 
-    if (pos_delta < diff)
+    //This first part of this condition will catch any NaN or Infinite values
+    if ((diff * 0.0 != 0.0) || (pos_delta < diff))
     {
         UnityTestResultsFailBegin(lineNumber);
 #ifdef UNITY_DOUBLE_VERBOSE
@@ -688,6 +784,77 @@ void UnityAssertDoublesWithin(const _UD delta,
     }
 }
 
+//-----------------------------------------------
+void UnityAssertDoubleIsInf(const _UD actual,
+                            const char* msg,
+                            const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_SKIP_EXECUTION;
+
+    // The rationale for not using 1.0/0.0 is given in UnityAssertFloatIsInf's body.
+    if ((1.0 / d_zero) != actual)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+#ifdef UNITY_DOUBLE_VERBOSE
+        UnityPrint(UnityStrExpected);
+        UnityPrint(UnityStrInf);
+        UnityPrint(UnityStrWas);
+        UnityPrintFloat((float)actual);
+#else
+        UnityPrint(UnityStrDelta);
+#endif
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
+//-----------------------------------------------
+void UnityAssertDoubleIsNegInf(const _UD actual,
+                               const char* msg,
+                               const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_SKIP_EXECUTION;
+
+    // The rationale for not using 1.0/0.0 is given in UnityAssertFloatIsInf's body.
+    if ((-1.0 / d_zero) != actual)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+#ifdef UNITY_DOUBLE_VERBOSE
+        UnityPrint(UnityStrExpected);
+        UnityPrint(UnityStrNegInf);
+        UnityPrint(UnityStrWas);
+        UnityPrintFloat((float)actual);
+#else
+        UnityPrint(UnityStrDelta);
+#endif
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
+//-----------------------------------------------
+void UnityAssertDoubleIsNaN(const _UD actual,
+                            const char* msg,
+                            const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_SKIP_EXECUTION;
+
+    if (actual == actual)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+#ifdef UNITY_DOUBLE_VERBOSE
+        UnityPrint(UnityStrExpected);
+        UnityPrint(UnityStrNaN);
+        UnityPrint(UnityStrWas);
+        UnityPrintFloat((float)actual);
+#else
+        UnityPrint(UnityStrDelta);
+#endif
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
 #endif // not UNITY_EXCLUDE_DOUBLE
 
 //-----------------------------------------------
@@ -819,7 +986,7 @@ void UnityAssertEqualStringArray( const char** expected,
             if (num_elements > 1)
             {
                 UnityPrint(UnityStrElement);
-                UnityPrintNumberByStyle((num_elements - j - 1), UNITY_DISPLAY_STYLE_UINT);
+                UnityPrintNumberByStyle((j), UNITY_DISPLAY_STYLE_UINT);
             }
             UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j]));
             UnityAddMsgIfSpecified(msg);