ceedling 0.15.1 → 0.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3629788d17df4fc73dc5ccde88d4d730eb6e2a8
-  data.tar.gz: 1a2e5b33152e1f4e866216666a8a31186482502c
+  metadata.gz: e64dca394cc4f8af27bfea39ebd102a923101893
+  data.tar.gz: 8c73db3acfec26c843fe9ac484559fbcd6477726
 SHA512:
-  metadata.gz: f3b31981913c03f72ca48ac7e154aaabd4dcc457669166aa0689dbe274561fa5c9cbf613709995685919f14a6edd7575d76a111f4cae79689d52481ef39e6730
-  data.tar.gz: 36e21fc258bdd692a1920a56e9d406871a0ceb1c843080dc9130b7ffa5c29690d993f559eafd651df176c362cfed88125e62b06e736f3f8144043d08e94ae4c2
+  metadata.gz: 7628d838e1b952a11adf2f1182c323004506ff897f2b59b423614e9a9ecd1833cfe0261888098c5f4a478c0c08bbad291cc24957e2d1c16ff4c6a297eac5a106
+  data.tar.gz: 71fe82714666bb2eb9fa05a45c6576d6ce876b687cd4ce1e877169c1bf18158e79059abad5b4d0822171fd818a7476e44a24fd91e651ae94a9808f992cdf84a7

data/Gemfile

@@ -3,7 +3,7 @@ source "http://rubygems.org/"
 gem "bundler", ">= 1.3.5"
 gem "rake", ">= 0.9.2.2"
 
-gem "rspec"
+gem "rspec", "~> 2.14.1"
 gem "require_all"
 gem "constructor"
 gem "diy"

data/Gemfile.lock

@@ -8,18 +8,14 @@ GEM
     rake (10.3.2)
     require_all (1.3.2)
     rr (1.1.2)
-    rspec (3.0.0)
-      rspec-core (~> 3.0.0)
-      rspec-expectations (~> 3.0.0)
-      rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.2)
-      rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.2)
-      rspec-support (~> 3.0.0)
-    rspec-support (3.0.2)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
     thor (0.19.1)
 
 PLATFORMS
@@ -32,5 +28,5 @@ DEPENDENCIES
   rake (>= 0.9.2.2)
   require_all
   rr
-  rspec
+  rspec (~> 2.14.1)
   thor

data/README.md

@@ -1,3 +1,19 @@
+Ceedling - Build/test system for C based on Ruby/Rake
+=====================================================
+
+Usage Documentation
+===================
+
+Documentation and license info exists [in the repo in docs/](docs/CeedlingPacket.md)
+
+Getting Started (Developers)
+============================
+
+    > git clone --recursive https://github.com/throwtheswitch/ceedling.git
+    > cd ceedling
+    > bundle install # Ensures you have all RubyGems needed
+    > bundle execute rake # Run all CMock library tests
+
 Using Ceedling inside of a project
 ==================================
 
@@ -26,7 +42,7 @@ started:
     :project:
       :use_exceptions: FALSE
       :use_test_preprocessor: TRUE
-      :use_auxiliary_dependencies: TRUE
+      :use_deep_dependencies: TRUE
       :build_root: build
     #  :release_build: TRUE
       :test_file_prefix: test_
@@ -86,9 +102,11 @@ started:
         # custom ceedling plugins
         # - ceedling_plugins
       :enabled:
-        # These two plugins ship with Ceedling.
+        # These plugins ship with Ceedling.
         - stdout_pretty_tests_report
-        - module_generator
+        # - stdout_ide_tests_report # IDE parseable output
+        # - teamcity_tests_report # TeamCity CI output (only enabled in TeamCity builds)
+        - module_generator # Adds tasks for creating code module files
     ...
 
 Finally, you'll need to create something like the following directory structure. This one matches the project.yml

data/lib/ceedling/version.rb

@@ -2,15 +2,15 @@
 module Ceedling
   module Version
     # @private
-    GEM = "0.15.1"
+    GEM = "0.15.2"
 
     # @private
     CEEDLING = GEM
     # @private
-    CEXCEPTION = "1.2.17"
+    CEXCEPTION = "1.3.17"
     # @private
-    CMOCK = "2.0.215"
+    CMOCK = "2.0.12"
     # @private
-    UNITY = "2.1.0"
+    UNITY = "2.1.118"
   end
 end

data/lib/ceedling/version.rb.erb

@@ -2,7 +2,7 @@
 module Ceedling
   module Version
     # @private
-    GEM = "0.11.2"
+    GEM = "0.15.2"
 
     # @private
     CEEDLING = "<%= versions["CEEDLING"] %>"

data/release/version.info

@@ -1 +1 @@
-0.15
+0.15.1

data/vendor/c_exception/Gemfile

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

data/vendor/c_exception/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (10.3.2)
+    test-unit (2.5.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  test-unit (~> 2.4)

data/vendor/c_exception/{docs/license.txt → LICENSE.txt}

@@ -1,4 +1,4 @@
- Copyright (c) 2007 Mark VanderVoord
+ Copyright (c) 2007-2014 Mark VanderVoord
 
  Permission is hereby granted, free of charge, to any person
  obtaining a copy of this software and associated documentation
@@ -12,14 +12,14 @@
  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.
 
- The end-user documentation included with the redistribution, if 
- any, must include the following acknowledgment: "This product 
- includes software developed for the CEXCeption Project, by Mark 
- VanderVoord and other contributors", in the same place and form 
- as other third-party acknowledgments.  Alternately, this 
- acknowledgment may appear in the software itself, in the same 
+ The end-user documentation included with the redistribution, if
+ any, must include the following acknowledgment: "This product
+ includes software developed for the CEXCeption Project, by Mark
+ VanderVoord and other contributors", in the same place and form
+ as other third-party acknowledgments.  Alternately, this
+ acknowledgment may appear in the software itself, in the same
  form and location as other such third-party acknowledgments.
- 
+
  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
@@ -27,4 +27,4 @@
  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.
+ OTHER DEALINGS IN THE SOFTWARE.

data/vendor/c_exception/README.md

@@ -0,0 +1,146 @@
+CException - Lightweight exception library for C
+================================================
+[![CException Build Status](https://api.travis-ci.org/ThrowTheSwitch/CException.png?branch=master)](https://travis-ci.org/ThrowTheSwitch/CException)
+
+_This Documentation Is Released Under a Creative Commons 3.0 Attribution Share-Alike License_
+
+CException is simple exception handling in C. It is significantly faster than full-blown C++ exception handling but loses some flexibility. It is portable to any platform supporting `setjmp`/`longjmp`.
+
+Getting Started
+================
+
+	> git clone --recursive https://github.com/throwtheswitch/cexception.git
+	> cd cexception
+	> bundle install # Ensures you have all RubyGems needed
+	> bundle execute rake # Run CException tests
+
+Usage
+=====
+
+*_So what's it good for?_*
+
+Mostly error handling. Passing errors down a long chain of function calls gets ugly. Sometimes really ugly. So what if you could just specify certain places where you want to handle errors, and all your errors were transferred there? Let's try a lame example:
+
+CException uses C standard library functions setjmp and longjmp to operate. As long as the target system has these two functions defined, this library should be useable with very little configuration. It even supports environments where multiple program flows are in use, such as real-time operating systems... we started this project for use in embedded systems... but it obviously can be used for larger systems too.
+
+*_Error Handling with CException:_*
+
+```
+void functionC(void) {
+  //do some stuff
+  if (there_was_a_problem)
+Throw(ERR_BAD_BREATH);
+//this stuff never gets called because of error
+```
+
+There are about a gajillion exception frameworks using a similar setjmp/longjmp method out there... and there will probably be more in the future. Unfortunately, when we started our last embedded project, all those that existed either (a) did not support multiple tasks (therefore multiple stacks) or (b) were way more complex than we really wanted. CException was born.
+
+Why?
+====
+
+* It's ANSI C, and it beats passing error codes around.
+
+* *You want something simple...* CException throws a single id. You can define those ID's to be whatever you like. You might even choose which type that number is for your project. But that's as far as it goes. We weren't interested in passing objects or structs or strings... just simple error codes. Fast. Easy to Use. Easy to Understand.
+
+* *Performance...* CException can be configured for single tasking or multitasking. In single tasking, there is very little overhead past the setjmp/longjmp calls (which are already fast). In multitasking, your only additional overhead is the time it takes you to determine a unique task id (0 to num_tasks).
+
+How?
+====
+
+Code that is to be protected are wrapped in `Try { }` blocks. The code inside the Try block is _protected_, meaning that if any Throws occur, program control is directly transferred to the start of the Catch block. The Catch block immediately follows the Try block. It's ignored if no errors have occurred.
+
+A numerical exception ID is included with Throw, and is passed into the Catch block. This allows you to handle errors differently or to report which error has occurred... or maybe it just makes debugging easier so you know where the problem was Thrown.
+
+Throws can occur from anywhere inside the Try block, directly in the function you're testing or even within function calls (nested as deeply as you like). There can be as many Throws as you like, just remember that execution of the guts of your Try block ends as soon as the first Throw is triggered. Once you throw, you're transferred to the Catch block. A silly example:
+
+```
+void SillyExampleWhichPrintsZeroThroughFive(void) {
+  CEXCEPTION_T e;
+  int i;
+  while (i = 0; i < 6; i++) {
+	Try {
+	  Throw(i);
+	  //This spot is never reached
+} Catch(e) {
+	  printf(“%i “, e);
+	}
+}
+```
+
+Limitations
+===========
+
+This library was made to be as fast as possible, and provide basic exception handling. It is not a full-blown exception library like C++. Because of this, there are a few limitations that should be observed in order to successfully utilize this library:
+
+* Do not directly `return` from within a `Try` block, nor `goto` into or out of a `Try` block.
+	* The `Try` macro allocates some local memory and alters a global pointer. These are cleaned up at the top of the `Catch` macro. Gotos and returns would bypass some of these steps, resulting in memory leaks or unpredictable behavior.
+
+* If (a) you change local (stack) variables within your `Try` block, and (b) wish to make use of the updated values after an exception is thrown, those variables should be made `volatile`.
+	* Note that this is ONLY for locals and ONLY when you need access to them after a `Throw`.
+	* Compilers optimize (and thank goodness they do). There is no way to guarantee that the actual memory location was updated and not just a register unless the variable is marked volatile.
+
+* Memory which is `malloc`'d within a `Try` block is not automatically released when an error is thrown. This will sometimes be desirable, and othertimes may not. It will be the responsibility of the code you put in the `Catch` block to perform this kind of cleanup.
+	* There's just no easy way to track `malloc`'d memory, etc., without replacing or wrapping `malloc` calls or something like that. This is a lightweight framework, so these options were not desirable.
+
+CException API
+==============
+
+* `Try { ... }`
+	* `Try` is a macro which starts a protected block. It MUST be followed by a pair of braces or a single protected line (similar to an 'if'), enclosing the data that is to be protected. It MUST be followed by a `Catch` block (don't worry, you'll get compiler errors to let you know if you mess any of that up).
+	* The `Try` block is your protected block. It contains your main program flow, where you can ignore errors (other than a quick `Throw` call). You may nest multiple `Try` blocks if you want to handle errors at multiple levels, and you can even rethrow an error from within a nested `Catch`.
+
+* `Catch(e) { }`
+	* `Catch` is a macro which ends the `Try` block and starts the error handling block. The `Catch` block is executed if and only if an exception was thrown while within the `Try` block. This error was thrown by a `Throw` call somewhere within `Try` (or within a function called within `Try`, or a function called by a function called within `Try`... you get the idea.).
+	* `Catch` receives a single id of type `CEXCEPTION_T` which you can ignore or use to handle the error in some way. You may throw errors from within Catches, but they will be caught by a `Try` wrapping the `Catch`, not the one immediately preceeding.
+
+* `Throw(e)`
+	* `Throw` is the method used to throw an error. `Throw`s should only occur from within a protected (`Try`...`Catch`) block, though it may easily be nested many function calls deep without an impact on performance or functionality. `Throw` takes a single argument, which is an exception id which will be passed to `Catch` as the reason for the error. If you wish to _re-throw_ an error, this can be done by calling `Throw(e)` with the error code you just caught. It _IS_ valid to throw from a `Catch` block.
+
+Configuration
+=============
+
+CException is a mostly portable library. It has one universal dependency, plus some macros which are required if working in a multi-tasking environment.
+
+The standard C library setjmp must be available. Since this is part of the standard library, it's all good.
+
+If working in a multitasking environment, you need a stack frame for each task. Therefore, you must define methods for obtaining an index into an array of frames and to get the overall number of id's are required. If the OS supports a method to retrieve task ID's, and those tasks are number 0, 1, 2... you are in an ideal situation. Otherwise, a more creative mapping function may be required. Note that this function is likely to be called twice for each protected block and once during a throw. This is the only added overhead in the system.
+
+You have options for configuring the library, if the defaults aren't good enough for you. You can add defines at the command prompt directly. You can always include a configuration file before including `CException.h`. You can make sure `CEXCEPTION_USE_CONFIG_FILE` is defined, which will force make CException look for `CExceptionConfig.h`, where you can define whatever you like. However you do it, you can override any or all of the following:
+
+* `CEXCEPTION_T`
+	* Set this to the type you want your exception id's to be. Defaults to an 'unsigned int'.
+
+* `CEXCEPTION_NONE`
+	* Set this to a number which will never be an exception id in your system. Defaults to `0x5a5a5a5a`.
+
+* `CEXCEPTION_GET_ID`
+	* If in a multi-tasking environment, this should be set to be a call to the function described in #2 above. It defaults to just return 0 all the time (good for single tasking environments, not so good otherwise).
+
+* `CEXCEPTION_NUM_ID`
+	* If in a multi-tasking environment, this should be set to the number of ID's required (usually the number of tasks in the system). Defaults to 1 (good for single tasking environments or systems where you will only use this from one task).
+
+* `CEXCEPTION_NO_CATCH_HANDLER (id)`
+	* This macro can be optionally specified. It allows you to specify code to be called when a Throw is made outside of Try...Catch protection. Consider this the emergency fallback plan for when something has gone terribly wrong.
+
+You may also want to include any header files which will commonly be needed by the rest of your application where it uses exception handling here. For example, OS header files or exception codes would be useful.
+
+Testing
+=======
+
+If you want to validate that CException works with your tools or that it works with your custom configuration, you may want to run the included test suite. This is the test suite (along with real projects we've used it on) that we use to make sure that things actually work the way we claim.
+The test suite included makes use of the Unity Test Framework. It will require a native C compiler. The example makefile and rakefile both use MinGW's gcc. Modify either to include the proper paths to tools, then run `make` to compile and run the test application.
+
+* `C_COMPILER` - The C compiler to use to perform the tests.
+* `C_LIBS` - The path to the C libraries (including setjmp).
+* `UNITY_DIR` - The path to the Unity framework (required to run tests)
+
+License
+=======
+
+*This software is licensed under the MIT License:
+Copyright (c) 2007-2014 Mark VanderVoord*
+
+*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/vendor/c_exception/{rakefile.rb → Rakefile}

@@ -22,8 +22,9 @@ SYMBOLS = '-DTEST -DCEXCEPTION_USE_CONFIG_FILE'
 
 CLEAN.include("#{HERE}*.out")
 
-task :default => [:clobber, :test]
-task :cruise => [:no_color, :default]
+task :no_color do
+  $colour_output = false
+end
 
 desc "performs a quick set of unit tests to confirm you're ready to go"
 task :test do
@@ -36,6 +37,6 @@ task :test do
   report output
 end
 
-task :no_color do
-  $colour_output = false
-end
+task :default => [:clobber, :test]
+task :ci => [:no_color, :default]
+task :cruise => :ci

data/vendor/c_exception/lib/CException.c

@@ -1,6 +1,9 @@
 #include "CException.h"
 
-volatile CEXCEPTION_FRAME_T CExceptionFrames[CEXCEPTION_NUM_ID] = { 0 };
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+volatile CEXCEPTION_FRAME_T CExceptionFrames[CEXCEPTION_NUM_ID] = {{ 0 }};
+#pragma GCC diagnostic pop
 
 //------------------------------------------------------------------------------------------
 //  Throw
@@ -13,14 +16,14 @@ void Throw(CEXCEPTION_T ExceptionID)
     {
         longjmp(*CExceptionFrames[MY_ID].pFrame, 1);
     }
-    CEXCEPTION_NO_CATCH_HANDLER(MY_ID);
+    CEXCEPTION_NO_CATCH_HANDLER(ExceptionID);
 }
 
 //------------------------------------------------------------------------------------------
 //  Explanation of what it's all for:
 //------------------------------------------------------------------------------------------
 /*
-#define Try                                                         
+#define Try
     {                                                                   <- give us some local scope.  most compilers are happy with this
         jmp_buf *PrevFrame, NewFrame;                                   <- prev frame points to the last try block's frame.  new frame gets created on stack for this Try block
         unsigned int MY_ID = CEXCEPTION_GET_ID;                         <- look up this task's id for use in frame array.  always 0 if single-tasking
@@ -30,12 +33,12 @@ void Throw(CEXCEPTION_T ExceptionID)
         if (setjmp(NewFrame) == 0) {                                    <- do setjmp.  it returns 1 if longjump called, otherwise 0
             if (&PrevFrame)                                             <- this is here to force proper scoping.  it requires braces or a single line to be but after Try, otherwise won't compile.  This is always true at this point.
 
-#define Catch(e)                                                    
+#define Catch(e)
             else { }                                                    <- this also forces proper scoping.  Without this they could stick their own 'else' in and it would get ugly
             CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;        <- no errors happened, so just set the exception id to NONE (in case it was corrupted)
-        }                                                           
+        }
         else                                                            <- an exception occurred
-        { e = CExceptionFrames[MY_ID].Exception; e=e;}                  <- assign the caught exception id to the variable passed in.  
+        { e = CExceptionFrames[MY_ID].Exception; e=e;}                  <- assign the caught exception id to the variable passed in.
         CExceptionFrames[MY_ID].pFrame = PrevFrame;                     <- make the pointer in the array point at the previous frame again, as if NewFrame never existed.
     }                                                                   <- finish off that local scope we created to have our own variables
     if (CExceptionFrames[CEXCEPTION_GET_ID].Exception != CEXCEPTION_NONE)  <- start the actual 'catch' processing if we have an exception id saved away

data/vendor/c_exception/release/build.info

@@ -1,2 +1,2 @@
-16
+17
 

data/vendor/c_exception/release/version.info

@@ -1,2 +1,2 @@
-1.2
+1.3
 

data/vendor/c_exception/test/CExceptionConfig.h

@@ -4,6 +4,7 @@
 #include "unity.h"
 
 extern volatile int TestingTheFallback;
+extern volatile int TestingTheFallbackId;
 
 //Optionally define the exception type (something like an int which can be directly assigned)
 #define CEXCEPTION_T    int
@@ -20,6 +21,7 @@ extern volatile int TestingTheFallback;
     }                                               \
     else                                            \
     {                                               \
+        TestingTheFallbackId = id;                  \
         TestingTheFallback--;                       \
     }                                               \
 }

data/vendor/c_exception/test/TestException.c

@@ -2,6 +2,7 @@
 #include "CException.h"
 
 volatile int TestingTheFallback;
+volatile int TestingTheFallbackId;
 
 void setUp(void)
 {
@@ -314,6 +315,7 @@ void test_AThrowWithoutATryCatchWillUseDefaultHandlerIfSpecified(void)
 
     //We know the fallback was run because it decrements the counter above
     TEST_ASSERT_FALSE(TestingTheFallback);
+    TEST_ASSERT_EQUAL(0xBE, TestingTheFallbackId);
 }
 
 void test_AThrowWithoutOutsideATryCatchWillUseDefaultHandlerEvenAfterTryCatch(void)
@@ -336,4 +338,5 @@ void test_AThrowWithoutOutsideATryCatchWillUseDefaultHandlerEvenAfterTryCatch(vo
 
     //We know the fallback was run because it decrements the counter above
     TEST_ASSERT_FALSE(TestingTheFallback);
-}
+    TEST_ASSERT_EQUAL(0xBE, TestingTheFallbackId);
+}