ceedling 0.20.3 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76c3dcdc10485c56db2c7327e5f9efac6295863c
-  data.tar.gz: 36798430e42c735498bcaca6b7a93c031b1c3adb
+  metadata.gz: fef79035eb5bbe9732905e831e227da8e2a8b788
+  data.tar.gz: 6c9c2c4b267ecec0395ef6c0028a4595f12dc8a7
 SHA512:
-  metadata.gz: 4b950c43a03327774484752588af61ced5f7b96e6f0421442f0f007e9ebfb644703250e4859b6317bcceca7fe7ce11a39d6b989b44e67366cd2bf25b33134015
-  data.tar.gz: 9be1131263be5c666088cae3c37e0452e7e7cbfd9b2bf91e400a36fe7890b4a5165fd3a888e37f39c7911a091b92ca0a0664d3592bcf0e9ef74993599202ffb5
+  metadata.gz: 95336d639633c43a5ecb27745fd4452645bd53a81b45715891f056aa660a581329f9fc7f326d1366ce2082a780fcd8ae74824a1eea91d9930f8c464b5e1059d2
+  data.tar.gz: b27f3cc0aef83627c2669ac2b0f23e4583906a724e30cfb58809cad4675ac37f8f2cde09710606383c06564558c7561eb8be33b85279063a0a1c1480e58bfb06

data/Gemfile

@@ -9,3 +9,6 @@ gem "constructor"
 gem "diy"
 gem "rr"
 gem "thor"
+
+#gem "pty",    :platforms => [ :ruby ] #automatically included on *nix platforms
+gem "popen4", :platforms => [ :mswin ]

data/Gemfile.lock

@@ -30,6 +30,7 @@ DEPENDENCIES
   bundler (>= 1.3.5)
   constructor
   diy
+  popen4
   rake (>= 0.9.2.2)
   require_all
   rr

data/Rakefile

@@ -7,4 +7,5 @@ RSpec::Core::RakeTask.new(:spec) do |t|
   t.pattern = 'spec/**/*_spec.rb'
 end
 
+task :default => [:spec]
 task :ci => [:spec]

data/bin/ceedling

@@ -44,7 +44,11 @@ unless (File.exists?("project.yml"))
                         'docs/CeedlingPacket.pdf',
                         'vendor/c_exception/docs/CExceptionSummary.pdf',
                         'vendor/cmock/docs/CMock Summary.pdf',
-                        'vendor/unity/docs/Unity Summary.pdf',
+                        'vendor/unity/docs/UnityAssertionsCheatSheetSuitableforPrintingandPossiblyFraming.pdf',
+                        'vendor/unity/docs/UnityAssertionsReference.pdf',
+                        'vendor/unity/docs/UnityConfigurationGuide.pdf',
+                        'vendor/unity/docs/UnityGettingStartedGuide.pdf',
+                        'vendor/unity/docs/UnityHelperScriptsGuide.pdf',
                       ]
 
           doc_files.each do |f|
@@ -143,11 +147,56 @@ unless (File.exists?("project.yml"))
 
 #===================================== We Have A Project Already ================================================
 else
+  begin
+    require 'pty'
+
+    #if available, we use PTY because it will live-stream our data instead of buffering it all up
+    def spawn_command(cmd, &block)
+      begin
+        PTY.spawn(cmd) do |stdout, stdin, pid|
+          begin
+            block.call(stdout)
+          rescue Errno::EIO
+          end
+        end
+      rescue Exception => e
+        STDERR.puts e.inspect unless (e == PTY::ChildExited)
+      end
+    end
+
+  rescue
 
-  require 'pty'
+    begin
+
+      require 'popen4'
+
+      #if pty wasn't available, we'll use POPEN instead
+      def spawn_command(cmd, &block)
+        POpen4.popen4(cmd) do |stdout, stderr, stdin|
+          begin
+            block.call(stdout)
+          rescue Errno::EIO
+          end
+        end
+      end
+
+    rescue
+
+      #if neither of these libraries were available, we can just shell out to the command and collect results
+      def spawn_command(cmd, &block)
+        block.call( `#{cmd}` )
+      end
+    end
+
+  end
+
+  require 'curses'
   require 'yaml'
   require 'rbconfig'
 
+  Curses.init_screen()
+  cols = Curses.cols
+
   #determine platform
   platform = begin
     case(RbConfig::CONFIG['host_os'])
@@ -196,6 +245,8 @@ else
         abort
       when /--gtest/
         options[:pretend_we_are_gtest] = true
+      when /--debug/
+        options[:outfile] = "debug.txt"
       else
         options[:args] += v + " "
     end
@@ -211,37 +262,39 @@ else
     ENV["PATH"] = path
   end
 
+  if (options[:outfile])
+    f = File.open(options[:outfile],'w')
+    f << ARGV.inspect << "\n\n"
+    f << options.inspect << "\n\n"
+  end
+
   #run rake and capture all the output
-  results = ""
   okay_to_print = !(options[:pretend_we_are_gtest])
-  begin
-    options[:cmd] = if (options[:pretest].nil? || options[:pretest].empty?)
-      "rake #{options[:args]}"
-    else
-      "#{options[:pretest]} && rake #{options[:args]}"
-    end
-    PTY.spawn(options[:cmd]) do |stdout, stdin, pid|
-      begin
-        stdout.each do |line|
-          okay_to_print = true if ((options[:pretend_we_are_gtest]) && (line.match(/\[\=+\]/)))
-          line.gsub!(/(?<!\w)rake(?!\w)/,'ceedling') if (options[:args].strip == "-T")
-          puts(line) if okay_to_print
+  options[:cmd] = if (options[:pretest].nil? || options[:pretest].empty?)
+    "rake #{options[:args]}"
+  else
+    "#{options[:pretest]} && rake #{options[:args]}"
+  end
+  spawn_command(options[:cmd]) do |stdout|
+    stdout.each do |line|
+      okay_to_print = true if ((options[:pretend_we_are_gtest]) && (line.match(/\[\=+\]/)))
+      if (okay_to_print)
+        f.puts(line) if (options[:outfile])
+        if (options[:args].strip == "-T")
+          line.gsub!(/(?<!\w)rake(?!\w)/,'ceedling')
+          if (line.length > cols)
+            endings = line.match(/[\r\n]+/)[0]
+            line.gsub!(endings,'')
+            line = line.slice(0, cols-3) + '...' + endings
+          end
         end
-      rescue Errno::EIO
+        puts(line)
       end
     end
-  rescue Exception => e
-    results += e.inspect #unless (e == PTY::ChildExited)
   end
 
-  #File.open("debug.txt",'w'){|f| f << ARGV.inspect << "\n\n" << options.inspect << "\n\n" << results }
-
-  #dump the results back out stdout unless otherwise specified
-  if (options[:outfile].nil?)
-    puts results
-  else
-    File.open(options[:outfile],'w') {|f| f << results }
-  end
+  f.close if options[:outfile]
+  true
 
 #===================================================================================================================
 end

data/lib/ceedling/configurator_plugins.rb

@@ -19,14 +19,10 @@ class ConfiguratorPlugins
     
       config[:plugins][:enabled].each do |plugin|
         path = File.join(root, plugin, "lib")
-        old_path = File.join( root, plugin )
 
         if ( not @file_wrapper.directory_listing( File.join( path, '*.rb' ) ).empty? )
           plugin_paths[(plugin + '_path').to_sym] = path
           @system_wrapper.add_load_path( path )
-        elsif ( not @file_wrapper.directory_listing( File.join( old_path, '*.rb' ) ).empty? )
-          plugin_paths[(plugin + '_path').to_sym] = old_path
-          @system_wrapper.add_load_path( old_path )
         end
       end
     end
@@ -59,17 +55,11 @@ class ConfiguratorPlugins
       config[:plugins][:enabled].each do |plugin|
         script_plugin_path = File.join(root, plugin, "lib", "#{plugin}.rb")
 
-        # Add the old path here to support legacy style. Eventaully remove.
-        old_script_plugin_path = File.join(root, plugin, "#{plugin}.rb")
 
         if @file_wrapper.exist?(script_plugin_path) or @file_wrapper.exist?(old_script_plugin_path)
           @script_plugins << plugin 
         end
 
-        # Print depreciation warning.
-        if @file_wrapper.exist?(old_script_plugin_path)
-          $stderr.puts "WARNING: Depreciated plugin style used in #{plugin}. Use new directory structure!"
-        end
       end
     end
     
@@ -85,14 +75,9 @@ class ConfiguratorPlugins
       config[:plugins][:enabled].each do |plugin|
         config_plugin_path = File.join(root, plugin, "config", "#{plugin}.yml")
 
-        # Add the old path here to support legacy style. Eventaully remove.
-        old_config_plugin_path = File.join(root, plugin, "#{plugin}.yml")
 
         if @file_wrapper.exist?(config_plugin_path)
           plugins_with_path << config_plugin_path
-        elsif @file_wrapper.exist?(old_config_plugin_path)
-          # there's a warning printed for this in find_script_plugins
-          plugins_with_path << old_config_plugin_path
         end
       end
     end
@@ -108,12 +93,9 @@ class ConfiguratorPlugins
     config[:plugins][:load_paths].each do |root|
       config[:plugins][:enabled].each do |plugin|
         default_path = File.join(root, plugin, 'config', 'defaults.yml')
-        old_default_path = File.join(root, plugin, 'defaults.yml')
 
         if @file_wrapper.exist?(default_path)
           defaults_with_path << default_path
-        elsif @file_wrapper.exist?(old_default_path)
-          defaults_with_path << old_default_path
         end
       end
     end

data/lib/ceedling/rules_cmock.rake

@@ -1,6 +1,6 @@
 
 
-rule(/#{CMOCK_MOCK_PREFIX}.+#{'\\'+EXTENSION_SOURCE}$/ => [
+rule(/#{CMOCK_MOCK_PREFIX}[^\/\\]+#{'\\'+EXTENSION_SOURCE}$/ => [
     proc do |task_name|
       @ceedling[:file_finder].find_header_input_for_mock_file(task_name)
     end  

data/lib/ceedling/tasks_base.rake

@@ -69,12 +69,16 @@ end
 if (not ENVIRONMENT.empty?)
 desc "List all configured environment variables."
 task :environment do
+  env_list = []
   ENVIRONMENT.each do |env|
     env.each_key do |key|
       name = key.to_s.upcase
-      puts " - #{name}: \"#{env[key]}\""
+	  env_list.push(" - #{name}: \"#{env[key]}\"")      
     end
   end
+  env_list.sort.each do |env_line|
+	puts env_line
+  end
 end
 end
 

data/lib/ceedling/tasks_tests.rake

@@ -1,9 +1,12 @@
 require 'ceedling/constants'
 
+task :test => [:directories] do
+  @ceedling[:test_invoker].setup_and_invoke(COLLECTION_ALL_TESTS)
+end
 
 namespace TEST_SYM do
-  
-  desc "Run all unit tests."
+
+  desc "Run all unit tests (also just 'test' works)."
   task :all => [:directories] do
     @ceedling[:test_invoker].setup_and_invoke(COLLECTION_ALL_TESTS)
   end
@@ -13,21 +16,21 @@ namespace TEST_SYM do
     message = "\nOops! '#{TEST_ROOT_NAME}:*' isn't a real task. " +
               "Use a real test or source file name (no path) in place of the wildcard.\n" +
               "Example: rake #{TEST_ROOT_NAME}:foo.c\n\n"
-  
+
     @ceedling[:streaminator].stdout_puts( message )
   end
-  
+
   desc "Run tests for changed files."
   task :delta => [:directories] do
     @ceedling[:test_invoker].setup_and_invoke(COLLECTION_ALL_TESTS, TEST_SYM, {:force_run => false})
   end
-  
+
   desc "Run tests by matching regular expression pattern."
   task :pattern, [:regex] => [:directories] do |t, args|
     matches = []
-    
+
     COLLECTION_ALL_TESTS.each { |test| matches << test if (test =~ /#{args.regex}/) }
-  
+
     if (matches.size > 0)
       @ceedling[:test_invoker].setup_and_invoke(matches, TEST_SYM, {:force_run => false})
     else
@@ -38,9 +41,9 @@ namespace TEST_SYM do
   desc "Run tests whose test path contains [dir] or [dir] substring."
   task :path, [:dir] => [:directories] do |t, args|
     matches = []
-    
+
     COLLECTION_ALL_TESTS.each { |test| matches << test if File.dirname(test).include?(args.dir.gsub(/\\/, '/')) }
-  
+
     if (matches.size > 0)
       @ceedling[:test_invoker].setup_and_invoke(matches, TEST_SYM, {:force_run => false})
     else

data/lib/ceedling/version.rb

@@ -2,7 +2,7 @@
 module Ceedling
   module Version
     # @private
-    GEM = "0.20.3"
+    GEM = "0.21.0"
     # @private
     CEEDLING = GEM
     # @private

data/lib/ceedling/version.rb.erb

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

data/plugins/fake_function_framework/README.md

@@ -0,0 +1,250 @@
+# A Fake Function Framework Plug-in for Ceedling
+
+This is a plug-in for [Ceedling](https://github.com/ThrowTheSwitch/Ceedling) to use the [Fake Function Framework](https://github.com/meekrosoft/fff) for mocking instead of CMock.
+
+Using fff provides less strict mocking than CMock, and allows for more loosely-coupled tests.
+And, when tests fail -- since you get the actual line number of the failure -- it's a lot easier to figure out what went wrong.
+
+## Installing the plug-in
+
+To use the plugin you need to 1) get the contents of this repo and 2) configure your project to use it.
+
+### Get the source
+
+The easiest way to get the source is to just clone this repo into the Ceedling plugin folder for your existing Ceedling project.
+(Don't have a Ceedling project already? [Here are instructions to create one.](http://www.electronvector.com/blog/try-embedded-test-driven-development-right-now-with-ceedling))
+From within `<your-project>/vendor/ceedling/plugins`, run:
+
+`git clone https://github.com/ElectronVector/fake_function_framework.git`
+
+This will create a new folder named `fake_function_framework` in the plugins folder.
+
+### Enable the plug-in.
+
+The plug-in is enabled from within your project.yml file.
+
+In the `:plugins` configuration, add `fake_function_framework` to the list of enabled plugins:
+
+```yaml
+:plugins:
+  :load_paths:
+    - vendor/ceedling/plugins
+  :enabled:
+    - stdout_pretty_tests_report
+    - module_generator
+    - fake_function_framework
+```
+*Note that you could put the plugin source in some other loaction.
+In that case you'd need to add a new path the `:load_paths`.*
+
+## How to use it
+
+You use fff with Ceedling the same way you used to use CMock.
+Modules can still be generated with the default module generator: `rake module:create[my_module]`.
+If you want to "mock" `some_module.h` in your tests, just `#include "mock_some_module.h"`.
+This creates a fake function for each of the functions defined in `some_module.h`.
+
+The name of each fake is the original function name with an appended `_fake`.
+For example, if we're generating fakes for a stack module with `push` and `pop` functions, we would have the fakes `push_fake` and `pop_fake`.
+These fakes are linked into our test executable so that any time our unit under test calls `push` or `pop` our fakes are called instead.
+
+Each of these fakes is actually a structure containing information about how the function was called, and what it might return.
+We can use Unity to inspect these fakes in our tests, and verify the interactions of our units.
+There is also a global structure named `fff` which we can use to check the sequence of calls.
+
+The fakes can also be configured to return particular values, so you can exercise the unit under test however you want.
+
+The examples below explain how to use fff to test a variety of module interactions.
+Each example uses fakes for a "display" module, created from a display.h file with `#include "mock_display.h"`. The `display.h` file must exist and must contain the prototypes for the functions to be faked.
+
+### Test that a function was called once
+
+```c
+void
+test_whenTheDeviceIsReset_thenTheStatusLedIsTurnedOff()
+{
+    // When
+    event_deviceReset();
+
+    // Then
+    TEST_ASSERT_EQUAL(1, display_turnOffStatusLed_fake.call_count);
+}
+```
+
+### Test that a function was NOT called
+
+```c
+void
+test_whenThePowerReadingIsLessThan5_thenTheStatusLedIsNotTurnedOn(void)
+{
+    // When
+    event_powerReadingUpdate(4);
+
+    // Then
+    TEST_ASSERT_EQUAL(0, display_turnOnStatusLed_fake.call_count);
+}
+```
+
+## Test that a single function was called with the correct argument
+
+```c
+void
+test_whenTheVolumeKnobIsMaxed_thenVolumeDisplayIsSetTo11(void)
+{
+    // When
+    event_volumeKnobMaxed();
+
+    // Then
+    TEST_ASSERT_EQUAL(1, display_setVolume_fake.call_count);
+    TEST_ASSERT_EQUAL(11, display_setVolume_fake.arg0_val);
+}
+```
+
+## Test that calls are made in a particular sequence
+
+```c
+void
+test_whenTheModeSelectButtonIsPressed_thenTheDisplayModeIsCycled(void)
+{
+    // When
+    event_modeSelectButtonPressed();
+    event_modeSelectButtonPressed();
+    event_modeSelectButtonPressed();
+
+    // Then
+    TEST_ASSERT_EQUAL_PTR((void*)display_setModeToMinimum, fff.call_history[0]);
+    TEST_ASSERT_EQUAL_PTR((void*)display_setModeToMaximum, fff.call_history[1]);
+    TEST_ASSERT_EQUAL_PTR((void*)display_setModeToAverage, fff.call_history[2]);
+}
+```
+
+## Fake a return value from a function
+
+```c
+void
+test_givenTheDisplayHasAnError_whenTheDeviceIsPoweredOn_thenTheDisplayIsPoweredDown(void)
+{
+    // Given
+    display_isError_fake.return_val = true;
+
+    // When
+    event_devicePoweredOn();
+
+    // Then
+    TEST_ASSERT_EQUAL(1, display_powerDown_fake.call_count);
+}
+```
+
+## Fake a function with a value returned by reference
+
+```c
+void
+test_givenTheUserHasTypedSleep_whenItIsTimeToCheckTheKeyboard_theDisplayIsPoweredDown(void)
+{
+    // Given
+    char mockedEntry[] = "sleep";
+    void return_mock_value(char * entry, int length)
+    {
+        if (length > strlen(mockedEntry))
+        {
+            strncpy(entry, mockedEntry, length);
+        }
+    }
+    display_getKeyboardEntry_fake.custom_fake = return_mock_value;
+
+    // When
+    event_keyboardCheckTimerExpired();
+
+    // Then
+    TEST_ASSERT_EQUAL(1, display_powerDown_fake.call_count);
+}
+```
+
+## Fake a function with a function pointer parameter
+
+```
+void
+test_givenNewDataIsAvailable_whenTheDisplayHasUpdated_thenTheEventIsComplete(void)
+{
+    // A mock function for capturing the callback handler function pointer.
+    void(*registeredCallback)(void) = 0;
+    void mock_display_updateData(int data, void(*callback)(void))
+    {
+        //Save the callback function.
+        registeredCallback = callback;
+    }
+    display_updateData_fake.custom_fake = mock_display_updateData;
+
+    // Given
+    event_newDataAvailable(10);
+
+    // When
+    if (registeredCallback != 0)
+    {
+        registeredCallback();
+    }
+
+    // Then
+    TEST_ASSERT_EQUAL(true, eventProcessor_isLastEventComplete());
+}
+```
+
+## Helper macros
+
+For convenience, there are also some helper macros that create new Unity-style asserts:
+
+- `TEST_ASSERT_CALLED(function)`: Asserts that a function was called once.
+- `TEST_ASSERT_NOT_CALLED(function)`: Asserts that a function was never called.
+- `TEST_ASSERT_CALLED_TIMES(times, function)`: Asserts that a function was called a particular number of times.
+- `TEST_ASSERT_CALLED_IN_ORDER(order, function)`: Asserts that a function was called in a particular order.
+
+Here's how you might use one of these instead of simply checking the call_count value:
+
+```c
+void
+test_whenTheDeviceIsReset_thenTheStatusLedIsTurnedOff()
+{
+    // When
+    event_deviceReset();
+
+    // Then
+    // This how to directly use fff...
+    TEST_ASSERT_EQUAL(1, display_turnOffStatusLed_fake.call_count);
+    // ...and this is how to use the helper macro.
+    TEST_ASSERT_CALLED(display_turnOffStatusLed);
+}
+```
+
+## Test setup
+
+All of the fake functions, and any fff global state are all reset automatically between each test.
+
+## CMock configuration
+
+Use still use some of the CMock configuration options for setting things like the mock prefix, and for including additional header files in the mock files.
+
+```yaml
+:cmock:
+    :mock_prefix: mock_
+        :includes:
+            -
+        :includes_h_pre_orig_header:
+            -
+        :includes_h_post_orig_header:
+            -
+        :includes_c_pre_header:
+            -
+        :includes_c_post_header:
+```
+
+## Running the tests
+
+There are unit and integration tests for the plug-in itself.
+These are run with the default `rake` task.
+The integration test runs the tests for the example project in examples/fff_example.
+For the integration tests to succeed, this repository must be placed in a Ceedling tree in the plugins folder.
+
+## More examples
+
+There is an example project in examples/fff_example.
+It shows how to use the plug-in with some full-size examples.