ceedling 0.30.0 → 0.31.0

data/examples/temp_sensor/build/test/cache/TestTemperatureCalculator.c

@@ -0,0 +1,70 @@
+#include "src/TemperatureCalculator.c"
+#include "src/Types.h"
+#include "/Library/Ruby/Gems/2.6.0/gems/ceedling-0.31.0/vendor/unity/src/unity.h"
+
+
+
+
+
+
+
+
+extern float TemperatureCalculator_Calculate(uint16_t val);
+
+
+
+void setUp(void)
+
+{
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testTemperatureCalculatorShouldCalculateTemperatureFromMillivolts(void)
+
+{
+
+  float result;
+
+
+
+
+
+
+
+  result = TemperatureCalculator_Calculate(1000);
+
+  UnityAssertFloatsWithin((UNITY_FLOAT)((0.01f)), (UNITY_FLOAT)((25.0f)), (UNITY_FLOAT)((result)), (((void*)0)), (UNITY_UINT)(24));
+
+
+
+  result = TemperatureCalculator_Calculate(2985);
+
+  UnityAssertFloatsWithin((UNITY_FLOAT)((0.01f)), (UNITY_FLOAT)((68.317f)), (UNITY_FLOAT)((result)), (((void*)0)), (UNITY_UINT)(27));
+
+
+
+  result = TemperatureCalculator_Calculate(3);
+
+  UnityAssertFloatsWithin((UNITY_FLOAT)((0.01f)), (UNITY_FLOAT)((-19.96f)), (UNITY_FLOAT)((result)), (((void*)0)), (UNITY_UINT)(30));
+
+}
+
+
+
+void testShouldReturnNegativeInfinityWhen_0_millivoltsInput(void)
+
+{
+
+  UnityAssertFloatSpecial((UNITY_FLOAT)((TemperatureCalculator_Calculate(0))), (((void*)0)), (UNITY_UINT)(35), UNITY_FLOAT_IS_NEG_INF);
+
+}

data/examples/temp_sensor/build/test/cache/TestTemperatureFilter.c

@@ -0,0 +1,154 @@
+#include "src/TemperatureFilter.h"
+#include "src/Types.h"
+#include "/Library/Ruby/Gems/2.6.0/gems/ceedling-0.31.0/vendor/unity/src/unity.h"
+
+
+
+
+void setUp(void)
+
+{
+
+  TemperatureFilter_Init();
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testShouldInitializeTemeratureToInvalidValue(void)
+
+{
+
+  TemperatureFilter_Init();
+
+  UnityAssertFloatSpecial((UNITY_FLOAT)((TemperatureFilter_GetTemperatureInCelcius())), (((void*)0)), (UNITY_UINT)(18), UNITY_FLOAT_IS_NEG_INF);
+
+}
+
+
+
+void testShouldInitializeTemperatureAfterCallToInit(void)
+
+{
+
+  TemperatureFilter_Init();
+
+  TemperatureFilter_ProcessInput(17.8f);
+
+  UnityAssertFloatsWithin((UNITY_FLOAT)((0.0001f)), (UNITY_FLOAT)((17.8f)), (UNITY_FLOAT)((TemperatureFilter_GetTemperatureInCelcius())), (((void*)0)), (UNITY_UINT)(25));
+
+
+
+  TemperatureFilter_Init();
+
+  TemperatureFilter_ProcessInput(32.6f);
+
+  UnityAssertFloatsWithin((UNITY_FLOAT)((0.0001f)), (UNITY_FLOAT)((32.6f)), (UNITY_FLOAT)((TemperatureFilter_GetTemperatureInCelcius())), (((void*)0)), (UNITY_UINT)(29));
+
+}
+
+
+
+void setValueAndVerifyResponse(float input, float response)
+
+{
+
+  float actual;
+
+  TemperatureFilter_ProcessInput(input);
+
+  actual = TemperatureFilter_GetTemperatureInCelcius();
+
+
+
+  if (input == +__builtin_huge_valf() ||
+
+      input == -__builtin_huge_valf() ||
+
+      ( sizeof(input) == sizeof(float) ? __inline_isnanf((float)(input)) : sizeof(input) == sizeof(double) ? __inline_isnand((double)(input)) : __inline_isnanl((long double)(input))))
+
+  {
+
+    UnityAssertFloatSpecial((UNITY_FLOAT)((actual)), (((void*)0)), (UNITY_UINT)(42), UNITY_FLOAT_IS_NEG_INF);
+
+  }
+
+  else
+
+  {
+
+    UnityAssertFloatsWithin((UNITY_FLOAT)((0.0001f)), (UNITY_FLOAT)((response)), (UNITY_FLOAT)((actual)), (((void*)0)), (UNITY_UINT)(46));
+
+  }
+
+}
+
+
+
+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, -__builtin_huge_valf());
+
+  setValueAndVerifyResponse(14.3f, 14.3f);
+
+}
+
+
+
+void testShouldResetAverageIfPassedInfinityOrInvalidValue(void)
+
+{
+
+  setInvalidTemperatureAndVerifyReinitialized(-__builtin_huge_valf());
+
+  setInvalidTemperatureAndVerifyReinitialized(+__builtin_huge_valf());
+
+  setInvalidTemperatureAndVerifyReinitialized(+__builtin_nanf("0x7fc00000"));
+
+  setInvalidTemperatureAndVerifyReinitialized(-__builtin_nanf("0x7fc00000"));
+
+}

data/examples/temp_sensor/build/test/cache/TestTimerConductor.c

@@ -0,0 +1,57 @@
+#include "MockTimerInterruptHandler.h"
+#include "MockTimerModel.h"
+#include "MockTimerHardware.h"
+#include "src/TimerConductor.h"
+#include "src/Types.h"
+#include "/Library/Ruby/Gems/2.6.0/gems/ceedling-0.31.0/vendor/unity/src/unity.h"
+
+
+void setUp(void)
+
+{
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testInitShouldCallHardwareInit(void)
+
+{
+
+  TimerHardware_Init_CMockExpect(18);
+
+
+
+  TimerConductor_Init();
+
+}
+
+
+
+void testRunShouldGetSystemTimeAndPassOnToModelForEventScheduling(void)
+
+{
+
+  Timer_GetSystemTime_CMockExpectAndReturn(25, 1230);
+
+  TimerModel_UpdateTime_CMockExpect(26, 1230);
+
+  TimerConductor_Run();
+
+
+
+  Timer_GetSystemTime_CMockExpectAndReturn(29, 837460);
+
+  TimerModel_UpdateTime_CMockExpect(30, 837460);
+
+  TimerConductor_Run();
+
+}

data/examples/temp_sensor/build/test/cache/TestTimerHardware.c

@@ -0,0 +1,47 @@
+#include "MockTimerConfigurator.h"
+#include "src/TimerHardware.h"
+#include "src/Types.h"
+#include "/Library/Ruby/Gems/2.6.0/gems/ceedling-0.31.0/vendor/unity/src/unity.h"
+
+
+void setUp(void)
+
+{
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testInitShouldDelegateAppropriatelyToConfigurator(void)
+
+{
+
+  Timer_EnablePeripheralClocks_CMockExpect(16);
+
+  Timer_Reset_CMockExpect(17);
+
+  Timer_ConfigureMode_CMockExpect(18);
+
+  Timer_ConfigurePeriod_CMockExpect(19);
+
+  Timer_EnableOutputPin_CMockExpect(20);
+
+  Timer_Enable_CMockExpect(21);
+
+  Timer_ConfigureInterruptHandler_CMockExpect(22);
+
+  Timer_Start_CMockExpect(23);
+
+
+
+  TimerHardware_Init();
+
+}

data/examples/temp_sensor/build/test/cache/TestTimerModel.c

@@ -0,0 +1,31 @@
+#include "build/test/mocks/MockTaskScheduler.h"
+#include "src/TimerModel.h"
+#include "src/Types.h"
+#include "/Library/Ruby/Gems/2.6.0/gems/ceedling-0.31.0/vendor/unity/src/unity.h"
+
+
+void setUp(void)
+
+{
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testUpdateTimeShouldDelegateToTaskScheduler(void)
+
+{
+
+  TaskScheduler_Update_CMockExpect(16, 19387L);
+
+  TimerModel_UpdateTime(19387L);
+
+}

data/examples/temp_sensor/build/test/cache/TestUsartBaudRateRegisterCalculator.c

@@ -0,0 +1,38 @@
+#include "src/UsartBaudRateRegisterCalculator.h"
+#include "src/Types.h"
+#include "/Library/Ruby/Gems/2.6.0/gems/ceedling-0.31.0/vendor/unity/src/unity.h"
+
+
+void setUp(void)
+
+{
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testCalculateBaudRateRegisterSettingShouldCalculateRegisterSettingAppropriately(void)
+
+{
+
+
+
+  UnityAssertEqualNumber((UNITY_INT)((26)), (UNITY_INT)((UsartModel_CalculateBaudRateRegisterSetting(48000000, 115200))), (((void*)0)), (UNITY_UINT)(16), UNITY_DISPLAY_STYLE_INT);
+
+  UnityAssertEqualNumber((UNITY_INT)((6)), (UNITY_INT)((UsartModel_CalculateBaudRateRegisterSetting(3686400, 38400))), (((void*)0)), (UNITY_UINT)(17), UNITY_DISPLAY_STYLE_INT);
+
+  UnityAssertEqualNumber((UNITY_INT)((23)), (UNITY_INT)((UsartModel_CalculateBaudRateRegisterSetting(14318180, 38400))), (((void*)0)), (UNITY_UINT)(18), UNITY_DISPLAY_STYLE_INT);
+
+  UnityAssertEqualNumber((UNITY_INT)((20)), (UNITY_INT)((UsartModel_CalculateBaudRateRegisterSetting(12000000, 38400))), (((void*)0)), (UNITY_UINT)(19), UNITY_DISPLAY_STYLE_INT);
+
+  UnityAssertEqualNumber((UNITY_INT)((13)), (UNITY_INT)((UsartModel_CalculateBaudRateRegisterSetting(12000000, 56800))), (((void*)0)), (UNITY_UINT)(20), UNITY_DISPLAY_STYLE_INT);
+
+}

data/examples/temp_sensor/build/test/cache/TestUsartConductor.c

@@ -0,0 +1,73 @@
+#include "build/test/mocks/MockTaskScheduler.h"
+#include "MockUsartHardware.h"
+#include "MockUsartModel.h"
+#include "src/UsartConductor.h"
+#include "src/Types.h"
+#include "/Library/Ruby/Gems/2.6.0/gems/ceedling-0.31.0/vendor/unity/src/unity.h"
+
+
+void setUp(void)
+
+{
+
+}
+
+
+
+void tearDown(void)
+
+{
+
+}
+
+
+
+void testShouldInitializeHardwareWhenInitCalled(void)
+
+{
+
+  UsartModel_GetBaudRateRegisterSetting_CMockExpectAndReturn(18, 4);
+
+  UsartHardware_Init_CMockExpect(19, 4);
+
+  UsartModel_GetWakeupMessage_CMockExpectAndReturn(20, "Hey there!");
+
+  UsartHardware_TransmitString_CMockExpect(21, "Hey there!");
+
+
+
+  UsartConductor_Init();
+
+}
+
+
+
+void testRunShouldNotDoAnythingIfSchedulerSaysItIsNotTimeYet(void)
+
+{
+
+  TaskScheduler_DoUsart_CMockExpectAndReturn(28, (0));
+
+
+
+  UsartConductor_Run();
+
+}
+
+
+
+void testRunShouldGetCurrentTemperatureAndTransmitIfSchedulerSaysItIsTime(void)
+
+{
+
+  TaskScheduler_DoUsart_CMockExpectAndReturn(35, (1));
+
+  UsartModel_GetFormattedTemperature_CMockExpectAndReturn(36, "hey there");
+
+  UsartHardware_TransmitString_CMockExpect(37, "hey there");
+
+
+
+  UsartConductor_Run();
+
+}