ceedling 0.0.1

data/new_project_template/vendor/ceedling/vendor/c_exception/vendor/unity/extras/fixture/rakefile_helper.rb

@@ -0,0 +1,178 @@
+# ==========================================
+#   Unity Project - A Test Framework for C
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   [Released under MIT License. Please refer to license.txt for details]
+# ========================================== 
+
+require 'yaml'
+require 'fileutils'
+require HERE+'../../auto/unity_test_summary'
+require HERE+'../../auto/generate_test_runner'
+require HERE+'../../auto/colour_reporter'
+
+module RakefileHelpers
+
+  C_EXTENSION = '.c'
+  
+  def load_configuration(config_file)
+    unless ($configured)
+      $cfg_file = HERE+"../../targets/#{config_file}" unless (config_file =~ /[\\|\/]/)
+      $cfg = YAML.load(File.read($cfg_file))
+      $colour_output = false unless $cfg['colour']
+      $configured = true if (config_file != DEFAULT_CONFIG_FILE)
+    end
+  end
+  
+  def configure_clean
+    CLEAN.include($cfg['compiler']['build_path'] + '*.*') unless $cfg['compiler']['build_path'].nil?
+  end
+  
+  def configure_toolchain(config_file=DEFAULT_CONFIG_FILE)
+    config_file += '.yml' unless config_file =~ /\.yml$/
+    config_file = config_file unless config_file =~ /[\\|\/]/
+    load_configuration(config_file)
+    configure_clean
+  end
+  
+  def tackit(strings)
+    if strings.is_a?(Array)
+      result = "\"#{strings.join}\""
+    else
+      result = strings
+    end
+    return result
+  end
+  
+  def squash(prefix, items)
+    result = ''
+    items.each { |item| result += " #{prefix}#{tackit(item)}" }
+    return result
+  end
+
+  def build_compiler_fields
+    command  = tackit($cfg['compiler']['path'])
+    if $cfg['compiler']['defines']['items'].nil?
+      defines  = ''
+    else
+      defines  = squash($cfg['compiler']['defines']['prefix'], $cfg['compiler']['defines']['items'] + ['UNITY_OUTPUT_CHAR=UnityOutputCharSpy_OutputChar'])
+    end
+    options  = squash('', $cfg['compiler']['options'])
+    includes = squash($cfg['compiler']['includes']['prefix'], $cfg['compiler']['includes']['items'])
+    includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
+    return {:command => command, :defines => defines, :options => options, :includes => includes}
+  end
+
+  def compile(file, defines=[])
+    compiler = build_compiler_fields
+    unity_include = $cfg['compiler']['includes']['prefix']+'../../src'
+    cmd_str = "#{compiler[:command]}#{compiler[:defines]}#{compiler[:options]}#{compiler[:includes]} #{unity_include} #{file} " +
+      "#{$cfg['compiler']['object_files']['prefix']}#{$cfg['compiler']['object_files']['destination']}" +
+      "#{File.basename(file, C_EXTENSION)}#{$cfg['compiler']['object_files']['extension']}"
+    execute(cmd_str)
+  end
+  
+  def build_linker_fields
+    command  = tackit($cfg['linker']['path'])
+    if $cfg['linker']['options'].nil?
+      options  = ''
+    else
+      options  = squash('', $cfg['linker']['options'])
+    end
+    if ($cfg['linker']['includes'].nil? || $cfg['linker']['includes']['items'].nil?)
+      includes = ''
+    else
+      includes = squash($cfg['linker']['includes']['prefix'], $cfg['linker']['includes']['items'])
+    end
+    includes = includes.gsub(/\\ /, ' ').gsub(/\\\"/, '"').gsub(/\\$/, '') # Remove trailing slashes (for IAR)
+    return {:command => command, :options => options, :includes => includes}
+  end
+  
+  def link(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 +
+      $cfg['linker']['bin_files']['prefix'] + ' ' +
+      $cfg['linker']['bin_files']['destination'] +
+      exe_name + $cfg['linker']['bin_files']['extension']
+    execute(cmd_str)
+  end
+  
+  def build_simulator_fields
+    return nil if $cfg['simulator'].nil?
+    if $cfg['simulator']['path'].nil?
+      command = ''
+    else
+      command = (tackit($cfg['simulator']['path']) + ' ')
+    end
+    if $cfg['simulator']['pre_support'].nil?
+      pre_support = ''
+    else
+      pre_support = squash('', $cfg['simulator']['pre_support'])
+    end
+    if $cfg['simulator']['post_support'].nil?
+      post_support = ''
+    else
+      post_support = squash('', $cfg['simulator']['post_support'])
+    end
+    return {:command => command, :pre_support => pre_support, :post_support => post_support}
+  end
+  
+  def execute(command_string, verbose=true)
+    report command_string
+    output = `#{command_string}`.chomp
+    report(output) if (verbose && !output.nil? && (output.length > 0))
+    if ($?.exitstatus != 0)
+      raise "Command failed. (Returned #{$?.exitstatus})"
+    end
+    return output
+  end
+  
+  def report_summary
+    summary = UnityTestSummary.new
+    summary.set_root_path(HERE)
+    results_glob = "#{$cfg['compiler']['build_path']}*.test*"
+    results_glob.gsub!(/\\/, '/')
+    results = Dir[results_glob]
+    summary.set_targets(results)
+    summary.run
+  end
+  
+  def run_tests
+    report 'Running Unity system tests...'
+    
+    # Tack on TEST define for compiling unit tests
+    load_configuration($cfg_file)
+    test_defines = ['TEST']
+    $cfg['compiler']['defines']['items'] = [] if $cfg['compiler']['defines']['items'].nil?
+    
+    # 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'
+    
+    # Build object files
+    src_files.each { |f| compile(f, test_defines) }
+    obj_list = src_files.map {|f| File.basename(f.ext($cfg['compiler']['object_files']['extension'])) }
+    
+    # Link the test executable
+    test_base = "framework_test"
+    link(test_base, obj_list)
+      
+    # Execute unit test and generate results file
+    simulator = build_simulator_fields
+    executable = $cfg['linker']['bin_files']['destination'] + test_base + $cfg['linker']['bin_files']['extension']
+    if simulator.nil?
+      cmd_str = executable + " -v -r"
+    else
+      cmd_str = "#{simulator[:command]} #{simulator[:pre_support]} #{executable} #{simulator[:post_support]}"
+    end
+    output = execute(cmd_str)
+    test_results = $cfg['compiler']['build_path'] + test_base
+    if output.match(/OK$/m).nil?
+      test_results += '.testfail'
+    else
+      test_results += '.testpass'
+    end
+    File.open(test_results, 'w') { |f| f.print output }
+  end
+end

data/new_project_template/vendor/ceedling/vendor/c_exception/vendor/unity/extras/fixture/readme.txt

@@ -0,0 +1,9 @@
+Copyright (c) 2010 James Grenning and Contributed to Unity Project
+
+Unity Project - A Test Framework for C
+Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+[Released under MIT License. Please refer to license.txt for details]
+
+This Framework is an optional add-on to Unity.  By including unity_framework.h in place of unity.h,
+you may now work with Unity in a manner similar to CppUTest.  This framework adds the concepts of 
+test groups and gives finer control of your tests over the command line.

data/new_project_template/vendor/ceedling/vendor/c_exception/vendor/unity/extras/fixture/src/unity_fixture.c

@@ -0,0 +1,381 @@
+//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* ==========================================
+    Unity Project - A Test Framework for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+#include "unity_fixture.h"
+#include "unity_internals.h"
+#include <string.h>
+
+UNITY_FIXTURE_T UnityFixture;
+
+//If you decide to use the function pointer approach.
+int (*outputChar)(int) = putchar;
+
+int verbose = 0;
+
+void setUp(void)    { /*does nothing*/ }
+void tearDown(void) { /*does nothing*/ }
+
+void announceTestRun(int runNumber)
+{
+    UnityPrint("Unity test run ");
+    UnityPrintNumber(runNumber+1);
+    UnityPrint(" of ");
+    UnityPrintNumber(UnityFixture.RepeatCount);
+    UNITY_OUTPUT_CHAR('\n');
+}
+
+int UnityMain(int argc, char* argv[], void (*runAllTests)())
+{
+    int result = UnityGetCommandLineOptions(argc, argv);
+    int r;
+    if (result != 0)
+        return result;
+
+    for (r = 0; r < UnityFixture.RepeatCount; r++)
+    {
+        announceTestRun(r);
+        UnityBegin();
+        runAllTests();
+        UNITY_OUTPUT_CHAR('\n');
+        UnityEnd();
+    }
+
+    return UnityFailureCount();
+}
+
+static int selected(const char * filter, const char * name)
+{
+    if (filter == 0)
+        return 1;
+    return strstr(name, filter) ? 1 : 0;
+}
+
+static int testSelected(const char* test)
+{
+    return selected(UnityFixture.NameFilter, test);
+}
+
+static int groupSelected(const char* group)
+{
+    return selected(UnityFixture.GroupFilter, group);
+}
+
+static void runTestCase()
+{
+
+}
+
+void UnityTestRunner(unityfunction* setup,
+        unityfunction* testBody,
+        unityfunction* teardown,
+        const char * printableName,
+        const char * group,
+        const char * name,
+        const char * file, int line)
+{
+    if (testSelected(name) && groupSelected(group))
+    {
+        Unity.CurrentTestFailed = 0;
+        Unity.TestFile = file;
+        Unity.CurrentTestName = printableName;
+        Unity.CurrentTestLineNumber = line;
+        if (!UnityFixture.Verbose)
+            UNITY_OUTPUT_CHAR('.');
+        else
+            UnityPrint(printableName);
+
+        Unity.NumberOfTests++;
+        UnityMalloc_StartTest();
+        UnityPointer_Init();
+
+        runTestCase();
+        if (TEST_PROTECT())
+        {
+            setup();
+            testBody();
+        }
+        if (TEST_PROTECT())
+        {
+            teardown();
+        }
+        if (TEST_PROTECT())
+        {
+            UnityPointer_UndoAllSets();
+            if (!Unity.CurrentTestFailed)
+                UnityMalloc_EndTest();
+            UnityConcludeFixtureTest();
+        }
+        else
+        {
+            //aborting - jwg - di i need these for the other TEST_PROTECTS?
+        }
+    }
+}
+
+void UnityIgnoreTest()
+{
+    Unity.NumberOfTests++;
+    Unity.CurrentTestIgnored = 1;
+    UNITY_OUTPUT_CHAR('!');
+}
+
+
+//-------------------------------------------------
+//Malloc and free stuff
+//
+#define MALLOC_DONT_FAIL -1
+static int malloc_count;
+static int malloc_fail_countdown = MALLOC_DONT_FAIL;
+
+void UnityMalloc_StartTest()
+{
+    malloc_count = 0;
+    malloc_fail_countdown = MALLOC_DONT_FAIL;
+}
+
+void UnityMalloc_EndTest()
+{
+    malloc_fail_countdown = MALLOC_DONT_FAIL;
+    if (malloc_count != 0)
+    {
+        TEST_FAIL_MESSAGE("This test leaks!");
+    }
+}
+
+void UnityMalloc_MakeMallocFailAfterCount(int countdown)
+{
+    malloc_fail_countdown = countdown;
+}
+
+#ifdef malloc
+#undef malloc
+#endif
+
+#ifdef free
+#undef free
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct GuardBytes
+{
+    int size;
+    char guard[sizeof(int)];
+} Guard;
+
+
+static const char * end = "END";
+
+void * unity_malloc(size_t size)
+{
+    char* mem;
+    Guard* guard;
+
+    if (malloc_fail_countdown != MALLOC_DONT_FAIL)
+    {
+        if (malloc_fail_countdown == 0)
+            return 0;
+        malloc_fail_countdown--;
+    }
+
+    malloc_count++;
+
+    guard = (Guard*)malloc(size + sizeof(Guard) + 4);
+    guard->size = size;
+    mem = (char*)&(guard[1]);
+    memcpy(&mem[size], end, strlen(end) + 1);
+
+    return (void*)mem;
+}
+
+static int isOverrun(void * mem)
+{
+    Guard* guard = (Guard*)mem;
+    char* memAsChar = (char*)mem;
+    guard--;
+
+    return strcmp(&memAsChar[guard->size], end) != 0;
+}
+
+static void release_memory(void * mem)
+{
+    Guard* guard = (Guard*)mem;
+    guard--;
+
+    malloc_count--;
+    free(guard);
+}
+
+void unity_free(void * mem)
+{
+    int overrun = isOverrun(mem);//strcmp(&memAsChar[guard->size], end) != 0;
+    release_memory(mem);
+    if (overrun)
+    {
+        TEST_FAIL_MESSAGE("Buffer overrun detected during free()");
+    }
+}
+
+void* unity_calloc(size_t num, size_t size)
+{
+    void* mem = unity_malloc(num * size);
+    memset(mem, 0, num*size);
+    return mem;
+}
+
+void* unity_realloc(void * oldMem, size_t size)
+{
+    Guard* guard = (Guard*)oldMem;
+//    char* memAsChar = (char*)oldMem;
+    void* newMem;
+
+    if (oldMem == 0)
+        return unity_malloc(size);
+
+    guard--;
+    if (isOverrun(oldMem))
+    {
+        release_memory(oldMem);
+        TEST_FAIL_MESSAGE("Buffer overrun detected during realloc()");
+    }
+
+    if (size == 0)
+    {
+        release_memory(oldMem);
+        return 0;
+    }
+
+    if (guard->size >= size)
+        return oldMem;
+
+    newMem = unity_malloc(size);
+    memcpy(newMem, oldMem, size);
+    unity_free(oldMem);
+    return newMem;
+}
+
+
+//--------------------------------------------------------
+//Automatic pointer restoration functions
+typedef struct _PointerPair
+{
+    struct _PointerPair * next;
+    void ** pointer;
+    void * old_value;
+} PointerPair;
+
+enum {MAX_POINTERS=50};
+static PointerPair pointer_store[MAX_POINTERS];
+static int pointer_index = 0;
+
+void UnityPointer_Init()
+{
+    pointer_index = 0;
+}
+
+void UnityPointer_Set(void ** pointer, void * newValue)
+{
+    if (pointer_index >= MAX_POINTERS)
+        TEST_FAIL_MESSAGE("Too many pointers set");
+
+    pointer_store[pointer_index].pointer = pointer;
+    pointer_store[pointer_index].old_value = *pointer;
+    *pointer = newValue;
+    pointer_index++;
+}
+
+void UnityPointer_UndoAllSets()
+{
+    while (pointer_index > 0)
+    {
+        pointer_index--;
+        *(pointer_store[pointer_index].pointer) =
+        pointer_store[pointer_index].old_value;
+
+    }
+}
+
+int UnityFailureCount()
+{
+    return Unity.TestFailures;
+}
+
+int UnityGetCommandLineOptions(int argc, char* argv[])
+{
+    int i;
+    UnityFixture.Verbose = 0;
+    UnityFixture.GroupFilter = 0;
+    UnityFixture.NameFilter = 0;
+    UnityFixture.RepeatCount = 1;
+
+    if (argc == 1)
+        return 0;
+
+    for (i = 1; i < argc; )
+    {
+        if (strcmp(argv[i], "-v") == 0)
+        {
+            UnityFixture.Verbose = 1;
+            i++;
+        }
+        else if (strcmp(argv[i], "-g") == 0)
+        {
+            i++;
+            if (i >= argc)
+                return 1;
+            UnityFixture.GroupFilter = argv[i];
+            i++;
+        }
+        else if (strcmp(argv[i], "-n") == 0)
+        {
+            i++;
+            if (i >= argc)
+                return 1;
+            UnityFixture.NameFilter = argv[i];
+            i++;
+        }
+        else if (strcmp(argv[i], "-r") == 0)
+        {
+            UnityFixture.RepeatCount = 2;
+            i++;
+            if (i < argc)
+            {
+                if (*(argv[i]) >= '0' && *(argv[i]) <= '9')
+                {
+                    UnityFixture.RepeatCount = atoi(argv[i]);
+                    i++;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+void UnityConcludeFixtureTest()
+{
+    if (Unity.CurrentTestIgnored)
+    {
+        Unity.TestIgnores++;
+    }
+    else if (!Unity.CurrentTestFailed)
+    {
+        if (UnityFixture.Verbose)
+        {
+            UnityPrint(" PASS");
+            UNITY_OUTPUT_CHAR('\n');
+        }
+    }
+    else if (Unity.CurrentTestFailed)
+    {
+        Unity.TestFailures++;
+    }
+
+    Unity.CurrentTestFailed = 0;
+    Unity.CurrentTestIgnored = 0;
+}
+

data/new_project_template/vendor/ceedling/vendor/c_exception/vendor/unity/extras/fixture/src/unity_fixture.h

@@ -0,0 +1,81 @@
+//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* ==========================================
+    Unity Project - A Test Framework for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+#ifndef UNITY_FIXTURE_H_
+#define UNITY_FIXTURE_H_
+
+#include "unity.h"
+#include "unity_internals.h"
+#include "unity_fixture_malloc_overrides.h"
+#include "unity_fixture_internals.h"
+
+int UnityMain(int argc, char* argv[], void (*runAllTests)());
+
+
+#define TEST_GROUP(group)\
+    int TEST_GROUP_##group = 0
+
+#define TEST_SETUP(group) void TEST_##group##_SETUP()
+
+#define TEST_TEAR_DOWN(group) void TEST_##group##_TEAR_DOWN()
+
+
+#define TEST(group, name) \
+    void TEST_##group##_##name##_();\
+    void TEST_##group##_##name##_run()\
+    {\
+        UnityTestRunner(TEST_##group##_SETUP,\
+             TEST_##group##_##name##_,\
+            TEST_##group##_TEAR_DOWN,\
+            "TEST(" #group ", " #name ")",\
+            #group, #name,\
+            __FILE__, __LINE__);\
+    }\
+    void  TEST_##group##_##name##_()
+
+#define IGNORE_TEST(group, name) \
+    void TEST_##group##_##name##_();\
+    void TEST_##group##_##name##_run()\
+    {\
+        UnityIgnoreTest();\
+    }\
+    void  TEST_##group##_##name##_()
+
+#define DECLARE_TEST_CASE(group, name) \
+    void TEST_##group##_##name##_run()
+
+#define RUN_TEST_CASE(group, name) \
+        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)\
+    void TEST_##group##_GROUP_RUNNER_runAll();\
+    void TEST_##group##_GROUP_RUNNER()\
+    {\
+        TEST_##group##_GROUP_RUNNER_runAll();\
+    }\
+    void TEST_##group##_GROUP_RUNNER_runAll()
+
+//Call this from main
+#define RUN_TEST_GROUP(group)\
+    void TEST_##group##_GROUP_RUNNER();\
+    TEST_##group##_GROUP_RUNNER();
+
+//CppUTest Compatibility Macros
+#define UT_PTR_SET(ptr, newPointerValue)               UnityPointer_Set((void**)&ptr, (void*)newPointerValue)
+#define TEST_ASSERT_POINTERS_EQUAL(expected, actual)   TEST_ASSERT_EQUAL_PTR(expected, actual)
+#define TEST_ASSERT_BYTES_EQUAL(expected, actual)      TEST_ASSERT_EQUAL_HEX8(0xff & (expected), 0xff & (actual))
+#define FAIL(message)                                  TEST_FAIL((message))
+#define CHECK(condition)                               TEST_ASSERT_TRUE((condition))
+#define LONGS_EQUAL(expected, actual)                  TEST_ASSERT_EQUAL_INT((expected), (actual))
+#define STRCMP_EQUAL(expected, actual)                 TEST_ASSERT_EQUAL_STRING((expected), (actual))
+#define DOUBLES_EQUAL(expected, actual, delta)         TEST_ASSERT_FLOAT_WITHIN(((expected), (actual), (delta))
+
+void UnityMalloc_MakeMallocFailAfterCount(int count);
+
+#endif /* UNITY_FIXTURE_H_ */

data/new_project_template/vendor/ceedling/vendor/c_exception/vendor/unity/extras/fixture/src/unity_fixture_internals.h

@@ -0,0 +1,44 @@
+//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* ==========================================
+    Unity Project - A Test Framework for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+#ifndef UNITY_FIXTURE_INTERNALS_H_
+#define UNITY_FIXTURE_INTERNALS_H_
+
+typedef struct _UNITY_FIXTURE_T
+{
+    int Verbose;
+    unsigned int RepeatCount;
+    const char* NameFilter;
+    const char* GroupFilter;
+} UNITY_FIXTURE_T;
+
+typedef void unityfunction();
+void UnityTestRunner(unityfunction * setup,
+        unityfunction * body,
+        unityfunction * teardown,
+        const char * printableName,
+        const char * group,
+        const char * name,
+        const char * file, int line);
+
+void UnityIgnoreTest();
+void UnityMalloc_StartTest();
+void UnityMalloc_EndTest();
+int UnityFailureCount();
+int UnityGetCommandLineOptions(int argc, char* argv[]);
+void UnityConcludeFixtureTest();
+
+void UnityPointer_Set(void ** ptr, void * newValue);
+void UnityPointer_UndoAllSets();
+void UnityPointer_Init();
+
+void UnityAssertEqualPointer(const void * expected,
+                            const void * actual,
+                            const char* msg,
+                            const UNITY_LINE_TYPE lineNumber);
+
+#endif /* UNITY_FIXTURE_INTERNALS_H_ */

data/new_project_template/vendor/ceedling/vendor/c_exception/vendor/unity/extras/fixture/src/unity_fixture_malloc_overrides.h

@@ -0,0 +1,16 @@
+//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
+/* ==========================================
+    Unity Project - A Test Framework for C
+    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+    [Released under MIT License. Please refer to license.txt for details]
+========================================== */
+
+#ifndef UNITY_FIXTURE_MALLOC_OVERRIDES_H_
+#define UNITY_FIXTURE_MALLOC_OVERRIDES_H_
+
+#define malloc  unity_malloc
+#define calloc  unity_calloc
+#define realloc unity_realloc
+#define free    unity_free
+
+#endif /* UNITY_FIXTURE_MALLOC_OVERRIDES_H_ */