ceedling 0.31.1 → 1.0.1

data/examples/temp_sensor/test/TestUsartBaudRateRegisterCalculator.c

@@ -1,3 +1,10 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #include "unity.h"
 #include "Types.h"
 #include "UsartBaudRateRegisterCalculator.h"
@@ -13,9 +20,9 @@ void tearDown(void)
 void testCalculateBaudRateRegisterSettingShouldCalculateRegisterSettingAppropriately(void)
 {
   // BaudRate = MCK / (CD x 16) - per datasheet section 30.6.1.2 "Baud Rate Calculation Example"
-  TEST_ASSERT_EQUAL(26, UsartModel_CalculateBaudRateRegisterSetting(48000000, 115200));
-  TEST_ASSERT_EQUAL(6,  UsartModel_CalculateBaudRateRegisterSetting(3686400,  38400));
-  TEST_ASSERT_EQUAL(23, UsartModel_CalculateBaudRateRegisterSetting(14318180, 38400));
-  TEST_ASSERT_EQUAL(20, UsartModel_CalculateBaudRateRegisterSetting(12000000, 38400));
-  TEST_ASSERT_EQUAL(13, UsartModel_CalculateBaudRateRegisterSetting(12000000, 56800));
+  TEST_ASSERT_EQUAL_INT(26, UsartModel_CalculateBaudRateRegisterSetting(48000000, 115200));
+  TEST_ASSERT_EQUAL_INT(6,  UsartModel_CalculateBaudRateRegisterSetting(3686400,  38400));
+  TEST_ASSERT_EQUAL_INT(23, UsartModel_CalculateBaudRateRegisterSetting(14318180, 38400));
+  TEST_ASSERT_EQUAL_INT(20, UsartModel_CalculateBaudRateRegisterSetting(12000000, 38400));
+  TEST_ASSERT_EQUAL_INT(13, UsartModel_CalculateBaudRateRegisterSetting(12000000, 56800));
 }

data/examples/temp_sensor/test/TestUsartConductor.c

@@ -1,3 +1,10 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #include "unity.h"
 #include "Types.h"
 #include "UsartConductor.h"

data/examples/temp_sensor/test/TestUsartHardware.c

@@ -1,3 +1,10 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #include "unity.h"
 #include "Types.h"
 #include "UsartHardware.h"

data/examples/temp_sensor/test/TestUsartIntegrated.c

@@ -0,0 +1,63 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
+#include "unity.h"
+#include "Types.h"
+#include "UsartConductor.h"
+#include "UsartModel.h"
+#include "UsartHardware.h"
+#include "ModelConfig.h"
+#include "MockTaskScheduler.h"
+#include "MockUsartConfigurator.h"
+#include "MockUsartPutChar.h"
+#include "MockTemperatureFilter.h"
+#include "MockUsartBaudRateRegisterCalculator.h"
+#include <string.h>
+
+/* NOTE: we probably wouldn't actually perform this test on our own projects
+  but it's a good example of testing the same module(s) from multiple test
+  files, and therefore we like having it in this example. 
+*/
+
+#ifndef TEST_USART_INTEGRATED_STRING
+#define TEST_USART_INTEGRATED_STRING "THIS WILL FAIL"
+#endif
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testShouldInitializeHardwareWhenInitCalled(void)
+{
+  size_t i;
+  const char* test_str = TEST_USART_INTEGRATED_STRING;
+
+  UsartModel_CalculateBaudRateRegisterSetting_ExpectAndReturn(MASTER_CLOCK, USART0_BAUDRATE, 4);
+  Usart_ConfigureUsartIO_Expect();
+  Usart_EnablePeripheralClock_Expect();
+  Usart_Reset_Expect();
+  Usart_ConfigureMode_Expect();
+  Usart_SetBaudRateRegister_Expect(4);
+  Usart_Enable_Expect();
+  for (i=0; i < strlen(test_str); i++)
+  {
+    Usart_PutChar_Expect(test_str[i]);
+  }
+
+  UsartConductor_Init();
+}
+
+void testRunShouldNotDoAnythingIfSchedulerSaysItIsNotTimeYet(void)
+{
+  TaskScheduler_DoUsart_ExpectAndReturn(FALSE);
+
+  UsartConductor_Run();
+}

data/examples/temp_sensor/test/TestUsartModel.c

@@ -1,3 +1,10 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #include "unity.h"
 #include "Types.h"
 #include "UsartModel.h"
@@ -19,7 +26,7 @@ void testGetBaudRateRegisterSettingShouldReturnAppropriateBaudRateRegisterSettin
   uint8 dummyRegisterSetting = 17;
   UsartModel_CalculateBaudRateRegisterSetting_ExpectAndReturn(MASTER_CLOCK, USART0_BAUDRATE, dummyRegisterSetting);
 
-  TEST_ASSERT_EQUAL(dummyRegisterSetting, UsartModel_GetBaudRateRegisterSetting());
+  TEST_ASSERT_EQUAL_UINT8(dummyRegisterSetting, UsartModel_GetBaudRateRegisterSetting());
 }
 
 void testGetFormattedTemperatureFormatsTemperatureFromCalculatorAppropriately(void)

data/examples/temp_sensor/test/{TestAdcConductor.c → adc/TestAdcConductor.c}

@@ -1,3 +1,10 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #include "unity.h"
 #include "UnityHelper.h"
 #include "Types.h"

data/examples/temp_sensor/test/{TestAdcHardware.c → adc/TestAdcHardware.c}

@@ -1,3 +1,10 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #include "unity.h"
 #include "Types.h"
 #include "AdcHardware.h"
@@ -40,5 +47,5 @@ void testGetSampleShouldDelegateToAdcTemperatureSensor(void)
   Adc_ReadTemperatureSensor_ExpectAndReturn(847);
 
   sample = AdcHardware_GetSample();
-  TEST_ASSERT_EQUAL(847, sample);
+  TEST_ASSERT_EQUAL_INT(847, sample);
 }

data/examples/temp_sensor/test/{TestAdcModel.c → adc/TestAdcModel.c}

@@ -1,3 +1,10 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #include "unity.h"
 #include "Types.h"
 #include "AdcModel.h"
@@ -16,13 +23,13 @@ void tearDown(void)
 void testDoGetSampleShouldReturn_FALSE_WhenTaskSchedulerReturns_FALSE(void)
 {
   TaskScheduler_DoAdc_ExpectAndReturn(FALSE);
-  TEST_ASSERT_EQUAL(FALSE, AdcModel_DoGetSample());
+  TEST_ASSERT_FALSE(AdcModel_DoGetSample());
 }
 
 void testDoGetSampleShouldReturn_TRUE_WhenTaskSchedulerReturns_TRUE(void)
 {
   TaskScheduler_DoAdc_ExpectAndReturn(TRUE);
-  TEST_ASSERT_EQUAL(TRUE, AdcModel_DoGetSample());
+  TEST_ASSERT_TRUE(AdcModel_DoGetSample());
 }
 
 void testProcessInputShouldDelegateToTemperatureCalculatorAndPassResultToFilter(void)

data/examples/temp_sensor/test/support/UnityHelper.c

@@ -1,12 +1,19 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #include "unity.h"
 #include "unity_internals.h"
 #include "UnityHelper.h"
 
-#if 0
-void AssertEqualMyDataType(const MyDataType_T expected, const MyDataType_T actual, const unsigned short line)
+#if TEST_CUSTOM_EXAMPLE_STRUCT_T
+void AssertEqualEXAMPLE_STRUCT_T(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line)
 {
-  UNITY_TEST_ASSERT_EQUAL_INT(expected.length, actual.length, line, "MyDataType_T.length check failed");
-  UNITY_TEST_ASSERT_EQUAL_MEMORY(expected.buffer, actual.buffer, expected.length, line, "MyDataType_T.buffer check failed");
+  UNITY_TEST_ASSERT_EQUAL_INT(expected.x, actual.x, line, "EXAMPLE_STRUCT_T.x check failed");
+  UNITY_TEST_ASSERT_EQUAL_INT(expected.y, actual.y, line, "EXAMPLE_STRUCT_T.y check failed");
 }
 #endif
 

data/examples/temp_sensor/test/support/UnityHelper.h

@@ -1,12 +1,17 @@
+/* =========================================================================
+    Ceedling - Test-Centered Build System for C
+    ThrowTheSwitch.org
+    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    SPDX-License-Identifier: MIT
+========================================================================= */
+
 #ifndef _TESTHELPER_H
 #define _TESTHELPER_H
 
-// #include "MyTypes.h"
-
-#if 0
-void AssertEqualMyDataType(const MyDataType_T expected, const MyDataType_T actual, const unsigned short line);
-
-#define UNITY_TEST_ASSERT_EQUAL_MyDataType_T(expected, actual, line, message) {AssertEqualMyDataType(expected, actual, line);}
+#if TEST_CUSTOM_EXAMPLE_STRUCT_T
+#include "Types.h"
+void AssertEqualEXAMPLE_STRUCT_T(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line);
+#define UNITY_TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual, line, message) {AssertEqualEXAMPLE_STRUCT_T(expected, actual, line);}
 #endif
 
 #endif // _TESTHELPER_H

data/lib/ceedling/application.rb

@@ -0,0 +1,26 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# As Rake is removed, more and more functionality and code entrypoints will migrate here
+
+class Application
+
+  constructor :system_wrapper
+
+  def setup
+    @failures = false
+  end
+
+  def register_build_failure
+    @failures = true
+  end
+
+  def build_succeeded?
+    return (!@failures) && @system_wrapper.ruby_success?
+  end
+
+end

data/lib/ceedling/backtrace.gdb

@@ -0,0 +1,5 @@
+if $_isvoid ($_exitcode)
+  call ((void(*)(int))fflush)(0)
+  backtrace
+  kill
+end

data/lib/ceedling/build_batchinator.rb

@@ -0,0 +1,113 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class BuildBatchinator
+
+  constructor :configurator, :loginator, :reportinator
+
+  def setup
+    @queue = Queue.new
+  end
+
+  # Neaten up a build step with progress message and some scope encapsulation
+  def build_step(msg, heading: true, &block)
+    if heading
+      msg = @reportinator.generate_heading( @loginator.decorate( msg, LogLabels::RUN ) )
+    else # Progress message
+      msg = "\n" + @reportinator.generate_progress( @loginator.decorate( msg, LogLabels::RUN ) )
+    end
+
+    @loginator.log( msg )
+
+    yield # Execute build step block
+  end
+
+  # Parallelize work to be done:
+  #  - Enqueue things (thread-safe)
+  #  - Spin up a number of worker threads within constraints of project file config and amount of work
+  #  - Each worker thread consumes one item from queue and runs the block against its details
+  #  - When the queue is empty, the worker threads wind down
+  def exec(workload:, things:, &block)
+    workers = 0
+
+    case workload
+    when :compile
+      workers = @configurator.project_compile_threads
+    when :test
+      workers = @configurator.project_test_threads
+    else
+      raise NameError.new("Unrecognized batch workload type: #{workload}")
+    end
+
+    # Enqueue all the items the block will execute against
+    things.each { |thing| @queue << thing }
+
+    # Choose lesser of max workers or number of things to process & redefine workers
+    # (It's neater and more efficient to avoid workers we won't use)
+    workers = [workers, things.size].min
+
+    threads = (1..workers).collect do
+      thread = Thread.new do
+        Thread.handle_interrupt(Exception => :never) do
+          begin
+            Thread.handle_interrupt(Exception => :immediate) do
+              # Run tasks until there are no more enqueued
+              loop do
+                # pop(true) is non-blocking and raises ThreadError when queue is empty
+                yield @queue.pop(true)
+              end
+            end
+
+          # First, handle thread exceptions (should always be due to empty queue)
+          rescue ThreadError => e
+            # Typical case: do nothing and allow thread to wind down
+
+            # ThreadError outside scope of expected empty queue condition
+            unless e.message.strip.casecmp("queue empty")
+              # Shutdown all worker threads
+              shutdown_threads(threads) 
+              # Raise exception again after intervening
+              raise(e)
+            end
+
+          # Second, catch every other kind of exception so we can intervene with thread cleanup.
+          # Generally speaking, catching Exception is a no-no, but we must in this case.
+          # Raise the exception again so that:
+          #  1. Calling code knows something bad happened and handles appropriately
+          #  2. Ruby runtime can handle most serious problems
+          rescue Exception => e
+            # Shutdown all worker threads
+            shutdown_threads(threads) 
+            # Raise exception again after intervening
+            raise(e)
+          end
+        end
+      end
+
+      # Hand thread to Enumerable collect() routine
+      thread.abort_on_exception = true
+      thread
+    end
+
+    # Hand worker threads to scheduler / wait for them to finish
+    threads.each { |thread| thread.join }
+  end
+
+  ### Private ###
+
+  private
+
+  # Terminate worker threads other than ourselves (we're already winding down)
+  def shutdown_threads(workers)
+    workers.each do |thread|
+      next if thread == Thread.current
+      thread.terminate
+    end
+  end
+
+end
+

data/lib/ceedling/cacheinator.rb

@@ -1,3 +1,9 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class Cacheinator
 

data/lib/ceedling/cacheinator_helper.rb

@@ -1,3 +1,9 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class CacheinatorHelper
 

data/lib/ceedling/config_matchinator.rb

@@ -0,0 +1,192 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/exceptions'
+
+# :<section>:
+#   :<context>:
+#     :<optional operation>:
+#       :<optional matcher>:
+#         - <Value 1>
+#         - <Value 2>
+#         - ...
+
+class ConfigMatchinator
+
+  constructor :configurator, :loginator, :reportinator
+
+  def config_include?(primary:, secondary:, tertiary:nil)
+    # Create configurator accessor method
+    accessor = (primary.to_s + '_' + secondary.to_s).to_sym
+
+    # If no entry in configuration for secondary in primary, bail out
+    return false if not @configurator.respond_to?( accessor )
+
+    # If tertiary undefined, we've progressed as far as we need and already know the config is present
+    return true if tertiary.nil?
+
+    # Get element associated with this context
+    elem = @configurator.send( accessor )
+
+    # If [primary][secondary] is a simple array
+    if elem.is_a?(Array)
+      # A list instead of a hash, means [tertiary] is not present
+      return false
+
+    # If [primary][secondary] is a hash
+    elsif elem.is_a?(Hash)
+      return elem.include?( tertiary )
+    end
+
+    # Otherwise, [primary][secondary] is something that cannot contain a [tertiary] sub-hash
+    return false
+  end
+
+  def get_config(primary:, secondary:, tertiary:nil)
+    # Create configurator accessor method
+    accessor = (primary.to_s + '_' + secondary.to_s).to_sym
+
+    # If no entry in configuration for secondary in primary, bail out
+    return nil if not @configurator.respond_to?( accessor )
+
+    # Get config element associated with this secondary
+    elem = @configurator.send( accessor )
+
+    # If [primary][secondary] is a simple array
+    if elem.class == Array
+      # If no tertiary specified, then a simple array makes sense
+      return elem if tertiary.nil?
+
+      # Otherwise, if an tertiary is specified but we have an array, go boom
+      error = ":#{primary} ↳ :#{secondary} present in project configuration but does not contain :#{tertiary}."
+      raise CeedlingException.new( error )
+
+    # If [primary][secondary] is a hash
+    elsif elem.class == Hash
+      if not tertiary.nil?
+        # Bail out if we're looking for an [tertiary] sub-hash, but it's not present
+        return nil if not elem.include?( tertiary )
+
+        # Return array or hash at tertiary
+        return elem[tertiary]
+
+      # If tertiary is not being queried, but we have a hash, return the hash
+      else
+        return elem
+      end
+
+    # If [primary][secondary] is nothing we expect--something other than an array or hash
+    else
+      error = ":#{primary} ↳ :#{secondary} in project configuration is neither a list nor hash."
+      raise CeedlingException.new( error )
+    end
+
+    return nil
+  end
+
+  # Note: This method only relevant if hash includes test filepath matching keys
+  def matches?(hash:, filepath:, section:, context:, operation:nil)
+    _values = []
+
+    # Sanity check
+    if filepath.nil?
+      path = generate_matcher_path(section, context, operation)
+      error = "#{path} ↳ #{matcher} matching provided nil #{filepath}"
+      raise CeedlingException.new(error)
+    end
+
+    # Iterate through every hash touple [matcher key, values array]
+    # In prioritized order match test filepath against each matcher key.
+    # This order matches on special patterns first to ensure no funny business with simple substring matching 
+    #  1. All files wildcard ('*')
+    #  2. Regex (/.../)
+    #  3. Wildcard filepath matching (e.g. 'name*')
+    #  4. Any filepath matching (substring matching)
+    #
+    # Each element of the collected _values array will be an array of values.
+
+    hash.each do |matcher, values|
+      mtached = false
+      _matcher = matcher.to_s.strip
+
+      # 1. Try gross wildcard matching -- return values for all test filepaths if '*' is the matching key
+      if ('*' == _matcher)
+        matched = true
+
+      # 2. Try regular expression matching against all values matching keys that are regexes (ignore if not a valid regex)
+      #    Note: We use logical AND here so that we get a meaningful fall-through condition.
+      #          Nesting the actual regex matching beneath validity checking improperly catches unmatched regexes
+      elsif (regex?(_matcher)) and (!(form_regex(_matcher).match(filepath)).nil?)
+        matched = true
+
+      # 3. Try wildcard matching -- return values for any test filepath that matches with '*' expansion
+      #    Treat matcher as a regex:
+      #      1. Escape any regex characters (e.g. '-')
+      #      2. Convert any now escaped '\*'s into '.*'
+      #      3. Match filepath against regex-ified matcher
+      elsif (filepath =~ /#{Regexp.escape(matcher).gsub('\*', '.*')}/)
+        matched = true
+
+      # 4. Try filepath literal matching (including substring matching) with each matching key
+      #    Note: (3) will do this if the matcher key lacks a '*', but this is a just-in-case backup
+      elsif (filepath.include?(_matcher))
+        matched = true
+      end        
+
+      if matched
+        _values += values
+        matched_notice(section:section, context:context, operation:operation, matcher:_matcher, filepath:filepath)
+      else # No match
+        path = generate_matcher_path(section, context, operation)
+        @loginator.log("#{path} ↳ `#{matcher}` did not match #{filepath}", Verbosity::DEBUG)
+      end
+    end
+
+    # Flatten to handle list-nested YAML aliasing (should have already been flattened during validation)
+    return _values.flatten
+  end
+
+  ### Private ###
+
+  private
+
+  def matched_notice(section:, context:, operation:, matcher:, filepath:)
+    path = generate_matcher_path(section, context, operation)
+    @loginator.log("#{path} ↳ #{matcher} matched #{filepath}", Verbosity::OBNOXIOUS)
+  end
+
+  def generate_matcher_path(*keys)
+    return @reportinator.generate_config_walk(keys)
+  end
+
+  # Assumes expr is a string and has been stripped
+  def regex?(expr)
+    valid = true
+
+    if !expr.start_with?('/')
+      return false
+    end
+
+    if !expr.end_with? ('/')
+      return false
+    end
+
+    begin
+      Regexp.new(expr[1..-2])
+    rescue RegexpError
+      valid = false
+    end
+
+    return valid
+  end
+
+  # Assumes expr is /.../
+  def form_regex(expr)
+    return Regexp.new(expr[1..-2])
+  end
+
+end

data/lib/ceedling/config_walkinator.rb

@@ -0,0 +1,35 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class ConfigWalkinator
+  
+  def fetch_value(*keys, hash:, default:nil)
+    # Safe initial values
+    value = default
+    depth = 0
+
+    # Set walk variable
+    walk = hash
+
+    # Walk into hash & extract value at requested key sequence
+    keys.each { |symbol|
+      # Validate that we can fetch something meaningful
+      if !walk.is_a?( Hash) or !symbol.is_a?( Symbol ) or walk[symbol].nil?
+        value = default
+        break
+      end
+
+      # Walk into the hash one more level and update value
+      depth += 1
+      walk  = walk[symbol]
+      value = walk
+    } if !walk.nil?
+    
+    return value, depth
+  end
+  
+end