ceedling 0.0.1

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestTaskScheduler.c

@@ -0,0 +1,104 @@
+#include "unity.h"
+#include "Types.h"
+#include "TaskScheduler.h"
+
+void setUp(void)
+{
+  TaskScheduler_Init();
+}
+
+void tearDown(void)
+{
+}
+
+void testShouldScheduleUsartTaskAfter1000ms(void)
+{
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoUsart());
+
+  TaskScheduler_Update(999);
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoUsart());
+
+  TaskScheduler_Update(1000);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoUsart());
+}
+
+void testShouldClearUsartDoFlagAfterReported(void)
+{
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoUsart());
+  TaskScheduler_Update(1000);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoUsart());
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoUsart());
+}
+
+void testShouldScheduleUsartTaskEvery1000ms(void)
+{
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoUsart());
+
+  TaskScheduler_Update(1300);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoUsart());
+
+  TaskScheduler_Update(2000);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoUsart());
+
+  TaskScheduler_Update(3100);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoUsart());
+}
+
+void testShouldScheduleUsartTaskOnlyOncePerPeriod(void)
+{
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoUsart());
+  TaskScheduler_Update(1000);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoUsart());
+  TaskScheduler_Update(1001);
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoUsart());
+  TaskScheduler_Update(1999);
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoUsart());
+  TaskScheduler_Update(2000);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoUsart());
+}
+
+void testShouldScheduleAdcTaskAfter100ms(void)
+{
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoAdc());
+
+  TaskScheduler_Update(99);
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoAdc());
+
+  TaskScheduler_Update(100);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoAdc());
+}
+
+void testShouldClearAdcDoFlagAfterReported(void)
+{
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoAdc());
+  TaskScheduler_Update(100);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoAdc());
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoAdc());
+}
+
+void testShouldScheduleAdcTaskEvery100ms(void)
+{
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoAdc());
+
+  TaskScheduler_Update(121);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoAdc());
+
+  TaskScheduler_Update(200);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoAdc());
+
+  TaskScheduler_Update(356);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoAdc());
+}
+
+void testShouldScheduleAdcTaskOnlyOncePerPeriod(void)
+{
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoAdc());
+  TaskScheduler_Update(100);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoAdc());
+  TaskScheduler_Update(101);
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoAdc());
+  TaskScheduler_Update(199);
+  TEST_ASSERT_EQUAL(FALSE, TaskScheduler_DoAdc());
+  TaskScheduler_Update(200);
+  TEST_ASSERT_EQUAL(TRUE, TaskScheduler_DoAdc());
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestTemperatureCalculator.c

@@ -0,0 +1,33 @@
+#include "unity.h"
+#include "Types.h"
+#include "TemperatureCalculator.h"
+#include <math.h>
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testTemperatureCalculatorShouldCalculateTemperatureFromMillivolts(void)
+{
+  float result;
+
+  // Series resistor is 5k Ohms; Reference voltage is 3.0V
+  // R(t) = A * e^(B*t); R is resistance of thermisor; t is temperature in C
+  result = TemperatureCalculator_Calculate(1000);
+  TEST_ASSERT_FLOAT_WITHIN(0.01f, 25.0f, result);
+
+  result = TemperatureCalculator_Calculate(2985);
+  TEST_ASSERT_FLOAT_WITHIN(0.01f, 68.317f, result);
+
+  result = TemperatureCalculator_Calculate(3);
+  TEST_ASSERT_FLOAT_WITHIN(0.01f, -19.96f, result);
+}
+
+void testShouldReturnNegativeInfinityWhen_0_millivoltsInput(void)
+{
+  TEST_ASSERT_FLOAT_WITHIN(0.0000001f, -INFINITY, TemperatureCalculator_Calculate(0));
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestTemperatureFilter.c

@@ -0,0 +1,69 @@
+#include "unity.h"
+#include "Types.h"
+#include "TemperatureFilter.h"
+#include <math.h>
+
+void setUp(void)
+{
+  TemperatureFilter_Init();
+}
+
+void tearDown(void)
+{
+}
+
+void testShouldInitializeTemeratureToInvalidValue(void)
+{
+  TemperatureFilter_Init();
+  TEST_ASSERT_FLOAT_WITHIN(0.0001f, -INFINITY, TemperatureFilter_GetTemperatureInCelcius());
+}
+
+void testShouldInitializeTemperatureAfterCallToInit(void)
+{
+  TemperatureFilter_Init();
+  TemperatureFilter_ProcessInput(17.8f);
+  TEST_ASSERT_FLOAT_WITHIN(0.0001f, 17.8f, TemperatureFilter_GetTemperatureInCelcius());
+
+  TemperatureFilter_Init();
+  TemperatureFilter_ProcessInput(32.6f);
+  TEST_ASSERT_FLOAT_WITHIN(0.0001f, 32.6f, TemperatureFilter_GetTemperatureInCelcius());
+}
+
+void setValueAndVerifyResponse(float input, float response)
+{
+  float actual;
+  TemperatureFilter_ProcessInput(input);
+  actual = TemperatureFilter_GetTemperatureInCelcius();
+  TEST_ASSERT_FLOAT_WITHIN(0.0001f, response, actual);
+}
+
+void testShouldWeightEachSubsequentValueBy25PercentAfterInitialValue(void)
+{
+  TemperatureFilter_Init();
+  setValueAndVerifyResponse(0.0f, 0.0f);
+  setValueAndVerifyResponse(10.0f, 2.5f);
+  setValueAndVerifyResponse(10.0f, 4.375f);
+  setValueAndVerifyResponse(10.0f, 5.78125f);
+
+  TemperatureFilter_Init();
+  setValueAndVerifyResponse(100.0f, 100.0f);
+  setValueAndVerifyResponse(0.0f, 75.0f);
+  setValueAndVerifyResponse(0.0f, 56.25f);
+  setValueAndVerifyResponse(0.0f, 42.1875f);
+}
+
+void setInvalidTemperatureAndVerifyReinitialized(float invalidTemperature)
+{
+  TemperatureFilter_Init();
+  setValueAndVerifyResponse(100.0f, 100.0f);
+  setValueAndVerifyResponse(invalidTemperature, -INFINITY);
+  setValueAndVerifyResponse(14.3f, 14.3f);
+}
+
+void testShouldResetAverageIfPassedInfinityOrInvalidValue(void)
+{
+  setInvalidTemperatureAndVerifyReinitialized(-INFINITY);
+  setInvalidTemperatureAndVerifyReinitialized(+INFINITY);
+  setInvalidTemperatureAndVerifyReinitialized(+NAN);
+  setInvalidTemperatureAndVerifyReinitialized(-NAN);
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestTimerConductor.c

@@ -0,0 +1,32 @@
+#include "unity.h"
+#include "Types.h"
+#include "TimerConductor.h"
+#include "MockTimerHardware.h"
+#include "MockTimerModel.h"
+#include "MockTimerInterruptHandler.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testInitShouldCallHardwareInit(void)
+{
+  TimerHardware_Init_Expect();
+
+  TimerConductor_Init();
+}
+
+void testRunShouldGetSystemTimeAndPassOnToModelForEventScheduling(void)
+{
+  Timer_GetSystemTime_ExpectAndReturn(1230);
+  TimerModel_UpdateTime_Expect(1230);
+  TimerConductor_Run();
+
+  Timer_GetSystemTime_ExpectAndReturn(837460);
+  TimerModel_UpdateTime_Expect(837460);
+  TimerConductor_Run();
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestTimerHardware.c

@@ -0,0 +1,26 @@
+#include "unity.h"
+#include "Types.h"
+#include "TimerHardware.h"
+#include "MockTimerConfigurator.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testInitShouldDelegateAppropriatelyToConfigurator(void)
+{
+  Timer_EnablePeripheralClocks_Expect();
+  Timer_Reset_Expect();
+  Timer_ConfigureMode_Expect();
+  Timer_ConfigurePeriod_Expect();
+  Timer_EnableOutputPin_Expect();
+  Timer_Enable_Expect();
+  Timer_ConfigureInterruptHandler_Expect();
+  Timer_Start_Expect();
+
+  TimerHardware_Init();
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestTimerModel.c

@@ -0,0 +1,18 @@
+#include "unity.h"
+#include "Types.h"
+#include "TimerModel.h"
+#include "MockTaskScheduler.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testUpdateTimeShouldDelegateToTaskScheduler(void)
+{
+  TaskScheduler_Update_Expect(19387L);
+  TimerModel_UpdateTime(19387L);
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestUsartBaudRateRegisterCalculator.c

@@ -0,0 +1,21 @@
+#include "unity.h"
+#include "Types.h"
+#include "UsartBaudRateRegisterCalculator.h"
+
+void setUp(void)
+{
+}
+
+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));
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestUsartConductor.c

@@ -0,0 +1,40 @@
+#include "unity.h"
+#include "Types.h"
+#include "UsartConductor.h"
+#include "MockUsartModel.h"
+#include "MockUsartHardware.h"
+#include "MockTaskScheduler.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testShouldInitializeHardwareWhenInitCalled(void)
+{
+  UsartModel_GetBaudRateRegisterSetting_ExpectAndReturn(4);
+  UsartModel_GetWakeupMessage_ExpectAndReturn("Hey there!");
+  UsartHardware_TransmitString_Expect("Hey there!");
+  UsartHardware_Init_Expect(4);
+
+  UsartConductor_Init();
+}
+
+void testRunShouldNotDoAnythingIfSchedulerSaysItIsNotTimeYet(void)
+{
+  TaskScheduler_DoUsart_ExpectAndReturn(FALSE);
+
+  UsartConductor_Run();
+}
+
+void testRunShouldGetCurrentTemperatureAndTransmitIfSchedulerSaysItIsTime(void)
+{
+  TaskScheduler_DoUsart_ExpectAndReturn(TRUE);
+  UsartModel_GetFormattedTemperature_ExpectAndReturn("hey there");
+  UsartHardware_TransmitString_Expect("hey there");
+
+  UsartConductor_Run();
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestUsartHardware.c

@@ -0,0 +1,36 @@
+#include "unity.h"
+#include "Types.h"
+#include "UsartHardware.h"
+#include "MockUsartConfigurator.h"
+#include "MockUsartPutChar.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testInitShouldConfigureUsartPeripheralByCallingConfiguratorAppropriately(void)
+{
+  Usart_ConfigureUsartIO_Expect();
+  Usart_EnablePeripheralClock_Expect();
+  Usart_Reset_Expect();
+  Usart_ConfigureMode_Expect();
+  Usart_SetBaudRateRegister_Expect(73);
+  Usart_Enable_Expect();
+
+  UsartHardware_Init(73);
+}
+
+void testTransmitStringShouldSendDesiredStringOutUsingUsart(void)
+{
+  Usart_PutChar_Expect('h');
+  Usart_PutChar_Expect('e');
+  Usart_PutChar_Expect('l');
+  Usart_PutChar_Expect('l');
+  Usart_PutChar_Expect('o');
+  
+  UsartHardware_TransmitString("hello");
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/TestUsartModel.c

@@ -0,0 +1,40 @@
+#include "unity.h"
+#include "Types.h"
+#include "UsartModel.h"
+#include "ModelConfig.h"
+#include "MockTemperatureFilter.h"
+#include "MockUsartBaudRateRegisterCalculator.h"
+#include <math.h>
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void testGetBaudRateRegisterSettingShouldReturnAppropriateBaudRateRegisterSetting(void)
+{
+  uint8 dummyRegisterSetting = 17;
+  UsartModel_CalculateBaudRateRegisterSetting_ExpectAndReturn(MASTER_CLOCK, USART0_BAUDRATE, dummyRegisterSetting);
+
+  TEST_ASSERT_EQUAL(dummyRegisterSetting, UsartModel_GetBaudRateRegisterSetting());
+}
+
+void testGetFormattedTemperatureFormatsTemperatureFromCalculatorAppropriately(void)
+{
+  TemperatureFilter_GetTemperatureInCelcius_ExpectAndReturn(25.0f);
+  TEST_ASSERT_EQUAL_STRING("25.0 C\n", UsartModel_GetFormattedTemperature());
+}
+
+void testShouldReturnErrorMessageUponInvalidTemperatureValue(void)
+{
+  TemperatureFilter_GetTemperatureInCelcius_ExpectAndReturn(-INFINITY);
+  TEST_ASSERT_EQUAL_STRING("Temperature sensor failure!\n", UsartModel_GetFormattedTemperature());
+}
+
+void testShouldReturnWakeupMessage(void)
+{
+  TEST_ASSERT_EQUAL_STRING("It's Awesome Time!\n", UsartModel_GetWakeupMessage());
+}

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/support/UnityHelper.c

@@ -0,0 +1,12 @@
+#include "unity.h"
+#include "UnityHelper.h"
+#include <stdio.h>
+#include <string.h>
+
+#if 0
+void AssertEqualExampleStruct(const EXAMPLE_STRUCT_T expected, const EXAMPLE_STRUCT_T actual, const unsigned short line)
+{
+    UNITY_TEST_ASSERT_EQUAL_INT(expected.x, actual.x, line, "Example Struct Failed For Field x");
+    UNITY_TEST_ASSERT_EQUAL_INT(expected.y, actual.y, line, "Example Struct Failed For Field y");
+}
+#endif

data/new_project_template/vendor/ceedling/examples/temp_sensor/test/support/UnityHelper.h

@@ -0,0 +1,8 @@
+#ifndef _TESTHELPER_H
+#define _TESTHELPER_H
+
+#if 0
+#define TEST_ASSERT_EQUAL_EXAMPLE_STRUCT_T(expected, actual) {AssertEqualExampleStruct(expected, actual);}
+#endif
+
+#endif // _TESTHELPER_H

data/new_project_template/vendor/ceedling/lib/cacheinator.rb

@@ -0,0 +1,42 @@
+
+class Cacheinator
+
+  constructor :cacheinator_helper, :file_path_utils, :file_wrapper, :yaml_wrapper
+  
+  def cache_test_config(hash)
+    @yaml_wrapper.dump( @file_path_utils.form_test_build_cache_path( INPUT_CONFIGURATION_CACHE_FILE), hash )
+  end
+
+  def cache_release_config(hash)
+    @yaml_wrapper.dump( @file_path_utils.form_release_build_cache_path( INPUT_CONFIGURATION_CACHE_FILE ), hash )
+  end
+
+  
+  def diff_cached_test_file( filepath )
+    cached_filepath = @file_path_utils.form_test_build_cache_path( filepath )
+  
+    if (@file_wrapper.exist?( cached_filepath ) and (!@file_wrapper.compare( filepath, cached_filepath )))
+      @file_wrapper.cp(filepath, cached_filepath, {:preserve => false})
+      return filepath
+    elsif (!@file_wrapper.exist?( cached_filepath ))
+      @file_wrapper.cp(filepath, cached_filepath, {:preserve => false}) 
+      return filepath
+    end
+
+    return cached_filepath
+  end
+
+  
+  def diff_cached_test_config?(hash)
+    cached_filepath = @file_path_utils.form_test_build_cache_path(INPUT_CONFIGURATION_CACHE_FILE)
+    
+    return @cacheinator_helper.diff_cached_config?( cached_filepath, hash )
+  end
+
+  def diff_cached_release_config?(hash)
+    cached_filepath = @file_path_utils.form_release_build_cache_path(INPUT_CONFIGURATION_CACHE_FILE)
+    
+    return @cacheinator_helper.diff_cached_config?( cached_filepath, hash )
+  end
+  
+end

data/new_project_template/vendor/ceedling/lib/cacheinator_helper.rb

@@ -0,0 +1,12 @@
+
+class CacheinatorHelper
+
+  constructor :file_wrapper, :yaml_wrapper
+  
+  def diff_cached_config?(cached_filepath, hash)
+    return true if ( not @file_wrapper.exist?(cached_filepath) )
+    return true if ( (@file_wrapper.exist?(cached_filepath)) and (!(@yaml_wrapper.load(cached_filepath) == hash)) )
+    return false
+  end
+  
+end

data/new_project_template/vendor/ceedling/lib/cmock_builder.rb

@@ -0,0 +1,15 @@
+require 'cmock'
+
+class CmockBuilder
+  
+  attr_accessor :cmock
+  
+  def setup 
+    @cmock = nil
+  end
+  
+  def manufacture(cmock_config)
+    @cmock = CMock.new(cmock_config)
+  end
+
+end