ceedling 0.20.3 → 0.21.0

data/plugins/fake_function_framework/spec/spec_helper.rb

@@ -0,0 +1,96 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/plugins/fake_function_framework/src/fff_unity_helper.h

@@ -0,0 +1,33 @@
+#ifndef fff_unity_helper_H
+#define fff_unity_helper_H
+
+/*
+    FFF helper macros for Unity.
+*/
+
+/*
+    Fail if the function was not called the expected number of times.
+*/
+#define TEST_ASSERT_CALLED_TIMES(times_, function_)                         \
+    TEST_ASSERT_EQUAL_MESSAGE(times_,                                       \
+        function_ ## _fake.call_count,                                      \
+        "Function " #function_ " called the incorrect number of times.")
+/*
+    Fail if the function was not called exactly once.
+*/
+#define TEST_ASSERT_CALLED(function_) TEST_ASSERT_CALLED_TIMES(1, function_)
+
+/*
+    Fail if the function was called 1 or more times.
+*/
+#define TEST_ASSERT_NOT_CALLED(function_) TEST_ASSERT_CALLED_TIMES(0, function_)
+
+/*
+    Fail if the function was not called in this particular order.
+*/
+#define TEST_ASSERT_CALLED_IN_ORDER(order_, function_)                      \
+    TEST_ASSERT_EQUAL_PTR_MESSAGE((void *) function_,                       \
+        fff.call_history[order_],                                           \
+        "Function " #function_ " not called in order " #order_ )
+
+#endif

data/plugins/fake_function_framework/vendor/fff/LICENSE

@@ -0,0 +1,25 @@
+/*
+LICENSE
+
+The MIT License (MIT)
+
+Copyright (c) 2010 Michael Long
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/

data/plugins/fake_function_framework/vendor/fff/Makefile

@@ -0,0 +1,10 @@
+all:
+	mkdir -p build
+	cd gtest; $(MAKE) all
+	cd test; $(MAKE) all
+	cd examples; $(MAKE) all
+
+clean: 
+	cd gtest; $(MAKE) clean
+	cd test; $(MAKE) clean
+	cd examples; $(MAKE) clean

data/plugins/fake_function_framework/vendor/fff/README.md

@@ -0,0 +1,454 @@
+# Fake Function Framework  (fff)
+-----------------------------
+> How long can we _maintain_? I wonder. How long before one of us starts raving 
+> and jabbering at this boy? What will he think then? This same lonely desert 
+> was the last known home of the Manson family. Will he make that grim 
+> connection...
+
+## A Fake Function Framework for C
+fff is a micro-framework for creating fake C functions for tests.  Because life
+is too short to spend time hand-writing fake functions for testing.
+
+
+## Hello fake world!
+
+Say you are testing an embedded user interface and you have a function that 
+you want to create a fake for:
+
+    // UI.c
+    ...
+    void DISPLAY_init();
+    ...
+
+Here's how you would define a fake function for this in your test suite:
+
+    // test.c(pp)
+    #include "fff.h"
+    DEFINE_FFF_GLOBALS;
+    FAKE_VOID_FUNC(DISPLAY_init);
+
+And the unit test might look something like this:
+
+    TEST_F(GreeterTests, init_initialises_display)
+    {
+	    UI_init();
+	    ASSERT_EQ(DISPLAY_init_fake.call_count, 1);
+    }
+
+So what has happened here?  The first thing to note is that the framework is 
+header only, all you need to do to use it is download <tt>fff.h</tt> and include
+it in your test suite.  
+
+The magic is in the <tt>FAKE_VOID_FUNC</tt>.  This 
+expands a macro that defines a function returning <tt>void</tt> 
+which has zero arguments.  It also defines a struct 
+<tt>"function_name"_fake</tt> which contains all the information about the fake.
+For instance, <tt>DISPLAY_init_fake.call_count</tt>is incremented every time the faked 
+function is called.
+
+Under the hood it generates a struct that looks like this:
+
+    typedef struct DISPLAY_init_Fake { 
+        unsigned int call_count; 
+        unsigned int arg_history_len;
+        unsigned int arg_histories_dropped; 
+        void(*custom_fake)(); 
+    } DISPLAY_init_Fake;
+    DISPLAY_init_Fake DISPLAY_init_fake;
+
+
+
+
+
+## Capturing arguments
+
+Ok, enough with the toy examples.  What about faking functions with arguments?
+
+    // UI.c
+    ...
+    void DISPLAY_output(char * message);
+    ...
+
+Here's how you would define a fake function for this in your test suite:
+
+    FAKE_VOID_FUNC(DISPLAY_output, char *);
+
+And the unit test might look something like this:
+
+    TEST_F(UITests, write_line_outputs_lines_to_display)
+    {
+        char msg[] = "helloworld";
+        UI_write_line(msg);
+        ASSERT_EQ(DISPLAY_output_fake.call_count, 1);
+        ASSERT_EQ(strncmp(DISPLAY_output_fake.arg0_val, msg, 26), 0);
+    }
+
+
+There is no more magic here, the <tt>FAKE_VOID_FUNC</tt> works as in the 
+previous example.  The number of arguments that the function takes is calculated,
+ and the macro arguments following the function name defines the argument
+type (a char pointer in this example).
+
+A variable is created for every argument in the form 
+<tt>"function_name"fake.argN_val</tt>
+
+
+
+## Return values
+
+When you want to define a fake function that returns a value, you should use the
+<tt>FAKE_VALUE_FUNC</tt> macro.  For instance:
+
+    // UI.c
+    ...
+    unsigned int DISPLAY_get_line_capacity();
+    unsigned int DISPLAY_get_line_insert_index();
+    ...
+
+Here's how you would define fake functions for these in your test suite:
+
+    FAKE_VALUE_FUNC(unsigned int, DISPLAY_get_line_capacity);
+    FAKE_VALUE_FUNC(unsigned int, DISPLAY_get_line_insert_index);
+
+And the unit test might look something like this:
+    
+    TEST_F(UITests, when_empty_lines_write_line_doesnt_clear_screen)
+    {
+        // given
+        DISPLAY_get_line_insert_index_fake.return_val = 1;
+        char msg[] = "helloworld";
+        // when
+        UI_write_line(msg);
+        // then
+        ASSERT_EQ(DISPLAY_clear_fake.call_count, 0);
+    }
+
+Of course you can mix and match these macros to define a value function with 
+arguments, for instance to fake:
+
+    double pow(double base, double exponent);
+    
+you would use a syntax like this:
+
+    FAKE_VALUE_FUNC(double, pow, double, double);
+
+
+
+## Resetting a fake
+
+Good tests are isolated tests, so it is important to reset the fakes for each
+unit test.  All the fakes have a reset function to reset their arguments and 
+call counts.  It is good prectice is to call the reset function for all the 
+fakes in the setup function of your test suite.
+
+    void setup()
+    {
+        // Register resets
+        RESET_FAKE(DISPLAY_init);
+        RESET_FAKE(DISPLAY_clear);
+        RESET_FAKE(DISPLAY_output_message);
+        RESET_FAKE(DISPLAY_get_line_capacity);
+        RESET_FAKE(DISPLAY_get_line_insert_index);
+    }
+
+You might want to define a macro to do this:
+
+``` 
+/* List of fakes used by this unit tester */
+#define FFF_FAKES_LIST(FAKE)            \
+  FAKE(DISPLAY_init)                    \
+  FAKE(DISPLAY_clear)                   \
+  FAKE(DISPLAY_output_message)          \
+  FAKE(DISPLAY_get_line_capacity)       \
+  FAKE(DISPLAY_get_line_insert_index)
+
+void setup()
+{
+  /* Register resets */
+  FFF_FAKES_LIST(RESET_FAKE);
+
+  /* reset common FFF internal structures */
+  FFF_RESET_HISTORY();
+}
+```
+
+## Call history
+Say you want to test that a function calls functionA, then functionB, then 
+functionA again, how would you do that?  Well <tt>fff</tt> maintains a call 
+history so that it is easy to assert these expectations.
+
+Here's how it works:
+
+    FAKE_VOID_FUNC(voidfunc2, char, char);
+    FAKE_VALUE_FUNC(long, longfunc0);
+    
+    TEST_F(FFFTestSuite, calls_in_correct_order)
+    {
+    	longfunc0();
+    	voidfunc2();
+    	longfunc0();
+
+    	ASSERT_EQ(fff.call_history[0], (void *)longfunc0);
+    	ASSERT_EQ(fff.call_history[1], (void *)voidfunc2);
+    	ASSERT_EQ(fff.call_history[2], (void *)longfunc0);
+    }
+    
+They are reset by calling <tt>FFF_RESET_HISTORY();</tt>
+
+
+## Default Argument History
+
+The framework will by default store the arguments for the last ten calls made
+to a fake function.
+    
+    TEST_F(FFFTestSuite, when_fake_func_called_then_arguments_captured_in_history)
+    {
+        voidfunc2('g', 'h');
+        voidfunc2('i', 'j');
+        ASSERT_EQ('g', voidfunc2_fake.arg0_history[0]);
+        ASSERT_EQ('h', voidfunc2_fake.arg1_history[0]);
+        ASSERT_EQ('i', voidfunc2_fake.arg0_history[1]);
+        ASSERT_EQ('j', voidfunc2_fake.arg1_history[1]);
+    }
+
+There are two ways to find out if calls have been dropped.  The first is to 
+check the dropped histories counter:
+
+    TEST_F(FFFTestSuite, when_fake_func_called_max_times_plus_one_then_one_argument_history_dropped)
+    {
+        int i;
+        for(i = 0; i < 10; i++)
+        {
+            voidfunc2('1'+i, '2'+i);
+        }
+        voidfunc2('1', '2');
+        ASSERT_EQ(1u, voidfunc2_fake.arg_histories_dropped);
+    }
+
+The other is to check if the call count is greater than the history size:
+
+    ASSERT(voidfunc2_fake.arg_history_len < voidfunc2_fake.call_count);
+    
+The argument histories for a fake function are reset when the RESET_FAKE 
+function is called
+
+## User Defined Argument History
+
+If you wish to control how many calls to capture for argument history you can
+override the default by defining it before include the <tt>fff.h</tt> like this:
+
+    // Want to keep the argument history for 13 calls
+    #define FFF_ARG_HISTORY_LEN 13
+    // Want to keep the call sequence history for 17 function calls
+    #define FFF_CALL_HISTORY_LEN 17
+    
+    #include "../fff.h"
+
+
+## Function Return Value Sequences
+
+Often in testing we would like to test the behaviour of sequence of function call 
+events.  One way to do this with fff is to specify a sequence of return values
+with for the fake function.  It is probably easier to describe with an example:
+
+    // faking "long longfunc();"
+    FAKE_VALUE_FUNC(long, longfunc0);
+    
+    TEST_F(FFFTestSuite, return_value_sequences_exhausted)
+    {
+        long myReturnVals[3] = { 3, 7, 9 };
+        SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
+        ASSERT_EQ(myReturnVals[0], longfunc0());
+        ASSERT_EQ(myReturnVals[1], longfunc0());
+        ASSERT_EQ(myReturnVals[2], longfunc0());
+        ASSERT_EQ(myReturnVals[2], longfunc0());
+        ASSERT_EQ(myReturnVals[2], longfunc0());
+    }
+
+By specifying a return value sequence using the <tt>SET_RETURN_SEQ</tt> macro, 
+the fake will return the values given in the parameter array in sequence.  When
+the end of the sequence is reached the fake will continue to return the last 
+value in the sequence indefinitely.
+
+## Custom Return Value Delegate
+
+You can specify your own function to provide the return value for the fake. This
+is done by setting the custom_fake member of the fake.  Here's an example:
+
+    #define MEANING_OF_LIFE 42
+    long my_custom_value_fake(void)
+    {
+        return MEANING_OF_LIFE;
+    }
+    TEST_F(FFFTestSuite, when_value_custom_fake_called_THEN_it_returns_custom_return_value)
+    {
+        longfunc0_fake.custom_fake = my_custom_value_fake;
+        long retval = longfunc0();
+        ASSERT_EQ(MEANING_OF_LIFE, retval);
+    }
+
+## How do I fake a function that returns a value by reference?
+The basic mechanism that FFF provides you in this case is the custom_fake field described in the *Custom Return Value Delegate* example above.
+ 
+You need to create a custom function (e.g. getTime_custom_fake) to produce the output optionally by use of a helper variable (e.g. getTime_custom_now) to retrieve that output from. Then some creativity to tie it all together. The most important part (IMHO) is to keep your test case readable and maintainable. 
+
+In case your project uses a C99 compliant C compiler you can even combine all this in a single unit test function so you can easily oversee all details of the test. See the example below.
+
+    /* The time structure */
+    typedef struct {
+       int hour, min;
+    } Time;
+    
+    /* Our fake function */
+    FAKE_VOID_FUNC(getTime, Time*);
+    
+    /* A test using the getTime fake function */
+    TEST_F(FFFTestSuite, when_value_custom_fake_called_THEN_it_returns_custom_output)
+    {
+        Time t;
+        Time getTime_custom_now;
+        void getTime_custom_fake(Time *now) {
+            *now = getTime_custom_now;
+        }
+        getTime_fake.custom_fake = getTime_custom_fake;
+    
+        /* given a specific time */
+        getTime_custom_now.hour = 13;
+        getTime_custom_now.min  = 05;
+    
+        /* when getTime is called */
+        getTime(&t);
+    
+        /* then the specific time must be produced */
+        ASSERT_EQ(t.hour, 13);
+        ASSERT_EQ(t.min,  05);
+    }
+
+## How do I fake a function with a function pointer parameter?
+Using FFF to stub functions that have function pointer parameter can cause problems when trying to stub them. Presented here is an example how to deal with this situation.
+
+If you need to stub a function that has a function pointer parameter, e.g. something like:
+
+```
+/* timer.h */
+typedef int timer_handle;
+extern int timer_start(timer_handle handle, long delay, void (*cb_function) (int arg), int arg);
+```
+
+Then creating a fake like below will horribly fail when trying to compile because the FFF macro will internally expand into an illegal variable ```int (*)(int) arg2_val```.
+
+```
+/* The fake, attempt one */
+FAKE_VALUE_FUNC(int,
+                timer_start,
+                timer_handle,
+                long,
+                void (*) (int argument),
+                int);
+```
+
+The solution to this problem is to create a bridging type that needs only to be visible in the unit tester. The fake will use that intermediate type. This way the compiler will not complain because the types match.
+
+```
+/* Additional type needed to be able to use callback in FFF */
+typedef void (*timer_cb) (int argument);
+
+/* The fake, attempt two */
+FAKE_VALUE_FUNC(int,
+                timer_start,
+                timer_handle,
+                long,
+                timer_cb,
+                int);
+```
+
+Here are some ideas how to create a test case with callbacks.
+
+```
+/* Unit test */
+TEST_F(FFFTestSuite, test_fake_with_function_pointer)
+{
+    int cb_timeout_called = 0;
+    int result = 0;
+    
+    void cb_timeout(int argument)
+    {
+      cb_timeout_called++;     
+    }
+    
+    int timer_start_custom_fake(timer_handle handle,
+                          long delay,
+                          void (*cb_function) (int arg),
+                          int arg)
+    {
+      if (cb_function) cb_function(arg);
+      return timer_start_fake.return_val;
+    }
+    
+    /* given the custom fake for timer_start */
+    timer_start_fake.return_val = 33;
+    timer_start_fake.custom_fake = timer_start_custom_fake;
+    
+    /* when timer_start is called 
+     * (actually you would call your own function-under-test
+     *  that would then call the fake function)
+     */
+    result = timer_start(10, 100, cb_timeout, 55);
+    
+    /* then the timer_start fake must have been called correctly */
+    ASSERT_EQ(result, 33);
+    ASSERT_EQ(timer_start_fake.call_count, 1);
+    ASSERT_EQ(timer_start_fake.arg0_val,   10);
+    ASSERT_EQ(timer_start_fake.arg1_val,   100);
+    ASSERT_EQ(timer_start_fake.arg2_val,   cb_timeout); /* callback provided by unit tester */
+    ASSERT_EQ(timer_start_fake.arg3_val,   55);
+    
+    /* and ofcourse our custom fake correctly calls the registered callback */
+    ASSERT_EQ(cb_timeout_called, 1);
+}
+```
+
+## Find out more...
+
+Look under the examlples directory for full length examples in both C and C++.
+There is also a test suite for the framework under the test directory.
+
+-------------------------
+
+## Benefits
+So whats the point?
+
+ * To make it easy to create fake functions for testing C code.
+ * It is simple - just include a header file and you are good to go.
+ * To work in both C and C++ test environments
+ 
+ 
+## Under the hood:
+ * The fff.h header file is generated by a ruby script
+ * There are tests under src/test
+ * There is an example for testing an embedded UI and a hardware driver under src/examples
+  
+
+## Cheat Sheet
+<table>
+    <tr>
+        <th>Macro</th>
+        <th>Description</th>
+        <th>Example</th>
+    </tr>
+    <tr>
+        <td>FAKE_VOID_FUNC(fn [,arg_types*]);</td>
+        <td>Define a fake function named fn returning void with n arguments</td>
+        <td>FAKE_VOID_FUNC(DISPLAY_output_message, const char*);</td>
+    </tr>
+    <tr>
+        <td>FAKE_VALUE_FUNC(return_type, fn [,arg_types*]);</td>
+        <td>Define a fake function returning a value with type return_type taking n arguments</td>
+        <td>FAKE_VALUE_FUNC(int, DISPLAY_get_line_insert_index);</td>
+    </tr>
+    <tr>
+        <td>RESET_FAKE(fn);</td>
+        <td>Reset the state of fake function called fn</td>
+        <td>RESET_FAKE(DISPLAY_init);</td>
+    </tr>
+</table>