firmware  v0.1.2
Chromation Spectrometer Dev-Kit
test_runner.c
1 // Pick a sensor
2 #ifdef LIS // <------------- $ make sensor=LIS
3 #include "LisConfigs.h"
4 #include "test_Lis.h"
5 #endif
6 #ifdef S13131 // <---------- $ make sensor=S13131
7 #endif
8 
9 #include <unity.h>
10 #include <mock.h>
11 #include "HardwareFake.h" // Fake hardware (registers, pins)
12 #include "StatusCodes.h" // Python-to-Firmware communication status codes
13 
14 #include "test_BiColorLed.h"
15 #include "test_ReadWriteBits.h"
16 #include "test_Flag.h"
17 #include "test_Spi.h"
18 #include "test_SpiSlave.h"
19 #include "test_SpiMaster.h"
20 #include "test_Queue.h"
21 #include "test_UartSpi.h"
22 #include "test_Usb.h"
23 #include "test_StatusCode.h"
24 
25 void (*setUp)(void);
26 void (*tearDown)(void);
27 void EmptySetup(void) {
28 }
29 void EmptyTeardown(void) {
30 }
31 Mock_s *mock;
32 void SetUp_Mock(void){
33  mock = Mock_new();
34 }
35 void TearDown_Mock(void){
36  Mock_destroy(mock);
37  mock = NULL;
38 }
39 bool Yep = true;
40 bool Nope = false;
41 
42 void test_BiColorLed(bool run_test)
43 {
44  if (run_test)
45  {
46  puts("# BiColorLed tests");
47 
48  setUp = EmptySetup;
49  tearDown = EmptyTeardown;
50 
51  puts("## BiColorLedOn");
52  RUN_TEST(BiColorLedOn_sets_bit_in_ddr);
53  puts("## BiColorLedOff");
54  RUN_TEST(BiColorLedOff_clears_bit_in_ddr);
55  puts("## BiColorLedGreen");
56  RUN_TEST(BiColorLedGreen_clears_bit_in_port);
57  puts("## BiColorLedRed");
58  RUN_TEST(BiColorLedRed_sets_bit_in_port);
59 
60  }
61 }
62 
63 void test_ReadWriteBits(bool run_test)
64 {
65  if (run_test)
66  {
67  puts("# ReadWriteBits tests");
68  setUp = EmptySetup;
69  tearDown = EmptyTeardown;
70  puts("## SetBit");
71  RUN_TEST(SetBit_sets_bit_in_register);
72  puts("## ClearBit");
73  RUN_TEST(ClearBit_clears_bit_in_register);
74  puts("## BitIsSet");
75  RUN_TEST(BitIsSet_returns_true_if_bit_is_set);
76  RUN_TEST(BitIsSet_returns_false_if_bit_is_clear);
77  puts("## BitIsClear");
78  RUN_TEST(BitIsClear_returns_true_if_bit_is_clear);
79  RUN_TEST(BitIsClear_returns_false_if_bit_is_set);
80  }
81 }
82 
83 void test_Spi(bool run_test)
84 {
85  if (run_test)
86  {
87  puts("# Spi tests");
88 
89  puts("## ClearSpiInterruptFlag");
90  setUp = EmptySetup;
91  tearDown = EmptyTeardown;
92  RUN_TEST(ClearSpiInterruptFlag_first_reads_SPI_status_register);
93  RUN_TEST(ClearSpiInterruptFlag_then_reads_SPI_data_register);
94 
95  puts("## _SpiTransferIsDone");
96  setUp = EmptySetup;
97  tearDown = EmptyTeardown;
98  RUN_TEST(SpiTransferIsDone_returns_true_if_the_SPI_Interrupt_Flag_is_set);
99  RUN_TEST(SpiTransferIsDone_returns_false_if_the_SPI_Interrupt_Flag_is_clear);
100  }
101 }
102 
103 void test_SpiSlave(bool run_test)
104 {
105  if (run_test)
106  {
107  puts("# SpiSlave tests");
108 
109  puts("## _SignalDataReady");
110  setUp = EmptySetup;
111  tearDown = EmptyTeardown;
112  RUN_TEST(SignalDataReady_drives_DataReady_LOW);
113 
114  puts("## DisableSpiInterrupt");
115  setUp = EmptySetup;
116  tearDown = EmptyTeardown;
117  RUN_TEST(DisableSpiInterrupt_clears_the_SPI_Interrupt_Enable_bit);
118 
119  puts("## EnableSpiInterrupt");
120  setUp = SetUp_Mock;
121  tearDown = TearDown_Mock;
122  RUN_TEST(EnableSpiInterrupt_clears_SPI_interrupt_flag);
123  RUN_TEST(EnableSpiInterrupt_enables_interrupt_SPI_Transfer_Complete);
124  RUN_TEST(EnableSpiInterrupt_consumes_6_cycles);
125 
126  puts("## SpiSlaveInit");
127  setUp = SetUp_Mock;
128  tearDown = TearDown_Mock;
129  RUN_TEST(SpiSlaveInit_makes_DataReady_an_output_pin);
130  RUN_TEST(SpiSlaveInit_idles_DataReady_high);
131  RUN_TEST(SpiSlaveInit_makes_Miso_an_output_pin);
132  RUN_TEST(SpiSlaveInit_enables_SPI);
133  RUN_TEST(SpiSlaveInit_enables_SPI_interrupt);
134 
135  puts("## SpiSlaveTxByte");
136  setUp = SetUp_Mock;
137  tearDown = TearDown_Mock;
138  RUN_TEST(SpiSlaveTxByte_loads_SPI_data_register_with_input_byte);
139  RUN_TEST(SpiSlaveTxByte_disables_SPI_ISR_before_signaling_data_ready);
140  RUN_TEST(SpiSlaveTxByte_drives_DataReady_LOW_to_signal_data_is_ready);
141  RUN_TEST(SpiSlaveTxByte_waits_until_SPI_transfer_is_done);
142  RUN_TEST(SpiSlaveTxByte_drives_DataReady_HIGH_immediately_after_SPI_transfer_finishes);
143  RUN_TEST(SpiSlaveTxByte_enables_SPI_ISR_after_transfer);
144 
145  puts("## SpiSlaveTx");
146  setUp = SetUp_Mock;
147  tearDown = TearDown_Mock;
148  RUN_TEST(SpiSlaveTx_sends_nbytes_of_input_buffer_to_SpiMaster);
149  }
150 }
151 
152 void SetUp_SpiMasterXfrByte(void) {
153  SetBit(Spi_SPSR, Spi_InterruptFlag);
154 }
155 void TearDown_SpiMasterXfrByte(void) {
156  ClearBit(Spi_SPSR, Spi_InterruptFlag);
157 }
158 void test_SpiMaster(bool run_test)
159 {
160  if (run_test)
161  {
162 
163  puts("# SpiMaster tests");
164 
165  puts("## SpiMasterInit");
166  setUp = SetUp_Mock;
167  tearDown = TearDown_Mock;
168  RUN_TEST(SpiMasterInit_idles_SlaveSelect_high);
169  RUN_TEST(SpiMasterInit_makes_SlaveSelect_an_output);
170  RUN_TEST(SpiMasterInit_makes_Miso_an_input);
171  RUN_TEST(SpiMasterInit_enables_pullup_on_Miso);
172  RUN_TEST(SpiMasterInit_makes_DataReady_an_input);
173  RUN_TEST(SpiMasterInit_enables_pullup_on_DataReady);
174  RUN_TEST(SpiMasterInit_makes_Mosi_an_output);
175  RUN_TEST(SpiMasterInit_makes_Sck_an_output);
176  RUN_TEST(SpiMasterInit_makes_this_MCU_the_SPI_Master);
177  RUN_TEST(SpiMasterInit_sets_SPI_Clock_to_10MHz_ext_osc_divided_by_8);
178  RUN_TEST(SpiMasterInit_enables_the_SPI_hardware_module);
179  RUN_TEST(SpiMasterInit_clears_SPI_interrupt_flag);
180 
181  puts("## SpiMasterXfrByte");
182  setUp = SetUp_SpiMasterXfrByte;
183  tearDown = TearDown_SpiMasterXfrByte;
184  RUN_TEST(SpiMasterXfrByte_selects_the_SPI_slave);
185  RUN_TEST(SpiMasterXfrByte_loads_SPI_data_reg_with_the_byte_to_send);
186  RUN_TEST(SpiMasterXfrByte_waits_until_the_transfer_is_done_by_reading_the_SPI_Interrupt_Flag);
187  RUN_TEST(SpiMasterXfrByte_unselects_the_SPI_slave);
188  RUN_TEST(SpiMasterXfrByte_clears_the_SPI_Interrupt_Flag_by_reading_the_SPI_data_reg);
189  RUN_TEST(SpiMasterXfrByte_returns_the_byte_in_the_SPI_data_reg);
190  }
191 }
192 
193 void test_Queue(bool run_test)
194 {
195  if (run_test)
196  {
197  puts("# Queue tests");
198 
199  puts("## QueueInit");
200  setUp = EmptySetup;
201  tearDown = EmptyTeardown;
202  RUN_TEST(QueueInit_returns_a_pointer_to_a_Queue_struct);
203  RUN_TEST(QueueInit_memory_for_Queue_struct_is_allocated_in_Queue_object_file);
204  RUN_TEST(QueueInit_assigns_input_buffer_as_Queue_buffer);
205  RUN_TEST(QueueInit_size_input_is_the_maximum_Queue_length);
206  RUN_TEST(QueueInit_initializes_Queue_with_length_0);
207 
208  puts("## QueueLength");
209  setUp = EmptySetup;
210  tearDown = EmptyTeardown;
211  RUN_TEST(QueueLength_increments_after_a_push);
212  RUN_TEST(QueueLength_does_not_increase_beyond_max_length);
213  RUN_TEST(QueueLength_decrements_after_a_pop);
214  RUN_TEST(QueueLength_does_not_decrease_below_zero);
215 
216  puts("## QueuePush");
217  setUp = EmptySetup;
218  tearDown = EmptyTeardown;
219  RUN_TEST(QueuePush_writes_byte_to_Queue_buffer);
220  RUN_TEST(QueuePush_writes_next_byte_to_address_after_previous_write);
221  RUN_TEST(QueuePush_does_not_write_byte_if_Queue_is_full);
222  RUN_TEST(QueuePush_hits_end_of_buffer_and_wraps_around_if_Queue_is_not_full);
223 
224  puts("## QueuePop");
225  setUp = EmptySetup;
226  tearDown = EmptyTeardown;
227  RUN_TEST(QueuePop_removes_oldest_byte_from_Queue);
228  RUN_TEST(QueuePop_returns_oldest_byte);
229  RUN_TEST(QueuePop_does_not_remove_any_bytes_if_Queue_is_empty);
230  RUN_TEST(QueuePop_returns_0_if_Queue_is_empty);
231  RUN_TEST(QueuePop_hits_end_of_buffer_and_wraps_around_if_Queue_is_not_empty);
232 
233  puts("## QueueIsFull");
234  setUp = EmptySetup;
235  tearDown = EmptyTeardown;
236  RUN_TEST(QueueIsFull_returns_true_if_Queue_is_full);
237  RUN_TEST(QueueIsFull_returns_false_if_Queue_is_not_full);
238 
239  puts("## QueueIsEmpty");
240  setUp = EmptySetup;
241  tearDown = EmptyTeardown;
242  RUN_TEST(QueueIsEmpty_returns_true_if_Queue_is_empty);
243  RUN_TEST(QueueIsEmpty_returns_false_if_Queue_is_not_empty);
244  }
245 }
246 
247 void test_UartSpi(bool run_test)
248 {
249  if (run_test)
250  {
251  puts("# UartSpi tests");
252 
253  puts("## UartSpiInit");
254  setUp = EmptySetup;
255  tearDown = EmptyTeardown;
256  RUN_TEST(UartSpiInit_clocks_SPI_bus_at_5MHz);
257  RUN_TEST(UartSpiInit_sets_Sck_as_an_output);
258  RUN_TEST(UartSpiInit_sets_AdcConv_to_idle_low);
259  RUN_TEST(UartSpiInit_sets_AdcConv_as_an_output);
260  RUN_TEST(UartSpiInit_enables_the_UART_in_Master_SPI_Mode);
261  RUN_TEST(UartSpiInit_uses_SPI_data_mode_CPOL_1_CPHA_1);
262  RUN_TEST(UartSpiInit_cfgs_SPI_to_transfer_MSB_first);
263  RUN_TEST(UartSpiInit_gives_SPI_control_over_Miso_and_Mosi_pin_behavior);
264  }
265 }
266 
267 void test_Lis(bool run_test)
268 {
269  if (run_test)
270  {
271  puts("# Lis tests");
272 
273  puts("## MSB");
274  setUp = EmptySetup;
275  tearDown = EmptyTeardown;
276  RUN_TEST(MSB_returns_most_significant_bit_of_16bit_input);
277 
278  puts("## LSB");
279  setUp = EmptySetup;
280  tearDown = EmptyTeardown;
281  RUN_TEST(LSB_returns_least_significant_bit_of_16bit_input);
282 
283  puts("## LisInit");
284  setUp = EmptySetup;
285  tearDown = EmptyTeardown;
286  RUN_TEST(LisInit_sets_PixSelect_as_an_output);
287  RUN_TEST(LisInit_idles_PixSelect_low);
288  RUN_TEST(LisInit_sets_Rst_as_an_output);
289  RUN_TEST(LisInit_idles_Rst_low);
290  RUN_TEST(LisInit_sets_Sync_as_an_input);
291  RUN_TEST(LisInit_sets_Clk_as_an_output);
292  RUN_TEST(LisInit_resets_PWM_timer_at_top);
293  RUN_TEST(LisInit_PWM_timer_top_is_OCR0A);
294  RUN_TEST(LisInit_PWM_timer_is_clocked_by_CPU_with_no_prescaling);
295  RUN_TEST(LisInit_sets_PWM_frequency_at_50kHz);
296  RUN_TEST(LisInit_sets_PWM_duty_cycle_to_50_percent);
297  RUN_TEST(LisInit_outputs_the_PWM_clock_on_pin_Clk);
298 
299  puts("## LisConfigIsValid");
300  setUp = EmptySetup;
301  tearDown = EmptyTeardown;
302  RUN_TEST(LisConfigIsValid_returns_false_if_binning_is_invalid);
303  RUN_TEST(LisConfigIsValid_returns_false_if_gain_is_invalid);
304  RUN_TEST(LisConfigIsValid_returns_false_if_active_rows_is_invalid);
305  RUN_TEST(LisConfigIsValid_returns_true_if_config_is_valid);
306 
307  puts("## _ConfigAs28bits");
308  setUp = EmptySetup;
309  tearDown = EmptyTeardown;
310  RUN_TEST(ConfigAs28bits_writes_config_as_little_endian_ie_binning_is_config_byte0_bit0);
311  RUN_TEST(ConfigAs28bits_sets_config_byte0_bit0_if_BINNING_ON);
312  RUN_TEST(ConfigAs28bits_clears_config_byte0_bit0_if_BINNING_OFF);
313  RUN_TEST(ConfigAs28bits_byte0_bit1_clear_and_bit2_clear_if_GAIN_1X);
314  RUN_TEST(ConfigAs28bits_byte0_bit1_clear_and_bit2_set_if_GAIN_2X5);
315  RUN_TEST(ConfigAs28bits_byte0_bit1_set_and_bit2_clear_if_GAIN_4X);
316  RUN_TEST(ConfigAs28bits_byte0_bit1_set_and_bit2_set_if_GAIN_5X);
317  RUN_TEST(ConfigAs28bits_bit3_to_bit27_set_if_ALL_ROWS_ACTIVE);
318  RUN_TEST(ConfigAs28bits_b3b8b13b18b23_set_if_ROW_1_ACTIVE);
319  RUN_TEST(ConfigAs28bits_b4b9b14b19b24_set_if_ROW_2_ACTIVE);
320  RUN_TEST(ConfigAs28bits_b5b10b15b20b25_set_if_ROW_3_ACTIVE);
321  RUN_TEST(ConfigAs28bits_b6b11b16b21b26_set_if_ROW_4_ACTIVE);
322  RUN_TEST(ConfigAs28bits_b7b12b17b22b27_set_if_ROW_5_ACTIVE);
323 
324  puts("## _WaitForLisClkLow");
325  setUp = EmptySetup;
326  tearDown = EmptyTeardown;
327  RUN_TEST(WaitForLisClkLow_clears_flag_PwmTimerMatchesOCF0B);
328  RUN_TEST(WaitForLisClkLow_waits_until_flag_PwmTimerMatchesOCF0B_is_set);
329 
330  puts("## _WaitForLisClkHigh");
331  setUp = EmptySetup;
332  tearDown = EmptyTeardown;
333  RUN_TEST(WaitForLisClkHigh_clears_flag_PwmTimerMatchesOCF0A);
334  RUN_TEST(WaitForLisClkHigh_waits_until_flag_PwmTimerMatchesOCF0A_is_set);
335 
336  puts("## _EnterLisProgrammingMode");
337  setUp = SetUp_Mock;
338  tearDown = TearDown_Mock;
339  RUN_TEST(EnterLisProgrammingMode_waits_for_LisClk_LOW);
340  RUN_TEST(EnterLisProgrammingMode_asserts_LisPixSelect_to_program_Lis);
341 
342  puts("## _WriteLisConfigBit");
343  setUp = SetUp_Mock;
344  tearDown = TearDown_Mock;
345  RUN_TEST(WriteLisConfigBit_outputs_bit_on_LisRst);
346  RUN_TEST(WriteLisConfigBit_waits_for_LisClk_HIGH);
347  RUN_TEST(WriteLisConfigBit_waits_for_LisClk_LOW);
348 
349  puts("## _Write28bitLisConfig");
350  setUp = SetUp_Mock;
351  tearDown = TearDown_Mock;
352  RUN_TEST(Write28bitLisConfig_writes_28bits_starting_at_byte0_bit0_and_ending_at_byte3_bit3);
353 
354  puts("## _ExitLisProgrammingMode");
355  setUp = EmptySetup;
356  tearDown = EmptyTeardown;
357  RUN_TEST(ExitLisProgrammingMode_outputs_LOW_on_pin_LisRst);
358  RUN_TEST(ExitLisProgrammingMode_outputs_LOW_on_pin_LisPixSelect);
359 
360  puts("## LisWriteConfig");
361  setUp = SetUp_Mock;
362  tearDown = TearDown_Mock;
363  RUN_TEST(LisWriteConfig_converts_config_to_28bit_sequence);
364  RUN_TEST(LisWriteConfig_enters_LIS_programming_mode);
365  RUN_TEST(LisWriteConfig_writes_28bits_to_LIS_setup_register);
366  RUN_TEST(LisWriteConfig_exits_LIS_programming_mode);
367 
368  puts("## LisExpose");
369  setUp = EmptySetup;
370  tearDown = EmptyTeardown;
371  RUN_TEST(LisExpose_waits_for_the_falling_edge_of_Lis_Clk);
372  RUN_TEST(LisExpose_starts_exposure_by_driving_Lis_Rst_HIGH);
373  RUN_TEST(LisExpose_counts_falling_edges_of_Lis_Clk_until_count_equals_exposure_ticks);
374  RUN_TEST(LisExpose_stops_exposure_by_driving_Lis_Rst_LOW);
375  }
376 }
377 
378 void test_Usb(bool run_test)
379 {
380  if (run_test)
381  {
382  puts("# Usb tests");
383 
384  puts("## _FtClockDatabus");
385  setUp = EmptySetup;
386  tearDown = EmptyTeardown;
387  RUN_TEST(FtClockDatabus_drives_FtClock_HIGH_if_direction_is_FtDrive);
388  RUN_TEST(FtClockDatabus_drives_FtClock_LOW_if_direction_is_FtSample);
389 
390  puts("## _FtReadDatabus");
391  setUp = EmptySetup;
392  tearDown = EmptyTeardown;
393  RUN_TEST(FtReadDatabus_copies_databus_pin_values_to_address_pbyte);
394 
395  puts("## _FtWriteDatabus");
396  setUp = EmptySetup;
397  tearDown = EmptyTeardown;
398  RUN_TEST(FtWriteDatabus_outputs_byte_on_databus_pins);
399 
400  puts("## _FtDatabusPinDirection");
401  setUp = EmptySetup;
402  tearDown = EmptyTeardown;
403  RUN_TEST(FtDatabusPinDirection_makes_databus_pins_outputs_if_direction_is_FtOut);
404  RUN_TEST(FtDatabusPinDirection_makes_databus_pins_inputs_if_direction_is_FtIn);
405 
406  puts("## FtSelectFT221X");
407  setUp = EmptySetup;
408  tearDown = EmptyTeardown;
409  RUN_TEST(FtSelectFT221X_drives_FtChipSelect_LOW);
410 
411  puts("## FtUnselectFT221X");
412  setUp = EmptySetup;
413  tearDown = EmptyTeardown;
414  RUN_TEST(FtUnselectFT221X_drives_FtChipSelect_HIGH);
415 
416  puts("## FtBusTurnaround");
417  setUp = SetUp_Mock;
418  tearDown = TearDown_Mock;
419  RUN_TEST(FtBusTurnaround_clocks_one_cycle_to_signal_data_drive_then_data_sample);
420 
421  puts("## FtIsOk");
422  setUp = EmptySetup;
423  tearDown = EmptyTeardown;
424  RUN_TEST(FtIsOk_returns_true_if_FtMiso_is_LOW);
425  RUN_TEST(FtIsOk_returns_false_if_FtMiso_is_HIGH);
426 
427  puts("## FtRead");
428  setUp = SetUp_Mock;
429  tearDown = TearDown_Mock;
430  RUN_TEST(FtRead_clocks_one_byte_out_of_the_FT221X);
431  RUN_TEST(FtRead_stores_the_byte_at_address_pbyte);
432 
433  puts("## FtWrite");
434  setUp = SetUp_Mock;
435  tearDown = TearDown_Mock;
436  RUN_TEST(FtWrite_signals_to_drive_data_onto_the_databus);
437  RUN_TEST(FtWrite_sets_microcontroller_databus_pins_as_outputs);
438  RUN_TEST(FtWrite_outputs_byte_on_databus_pins);
439  RUN_TEST(FtWrite_signals_FT221X_to_sample_the_databus);
440  RUN_TEST(FtWrite_sets_microcontroller_databus_pins_as_inputs);
441 
442  puts("## UsbRxbufferIsEmpty");
443  setUp = EmptySetup;
444  tearDown = EmptyTeardown;
445  RUN_TEST(UsbRxbufferIsEmpty_returns_true_if_pin_FT1248_MISO_is_HIGH);
446  RUN_TEST(UsbRxbufferIsEmpty_returns_false_if_pin_FT1248_MISO_is_LOW);
447 
448  puts("## UsbTxbufferIsFull");
449  setUp = EmptySetup;
450  tearDown = EmptyTeardown;
451  RUN_TEST(UsbTxbufferIsFull_returns_true_if_pin_MIOSIO0_is_HIGH);
452  RUN_TEST(UsbTxbufferIsFull_returns_false_if_pin_MIOSIO0_is_LOW);
453 
454  puts("## UsbReadByte");
455  setUp = SetUp_Mock;
456  tearDown = TearDown_Mock;
457  RUN_TEST(UsbReadByte_selects_the_FT221X);
458  RUN_TEST(UsbReadByte_drives_databus_with_read_command);
459  RUN_TEST(UsbReadByte_signals_FT221X_to_sample_the_databus);
460  RUN_TEST(UsbReadByte_reads_the_byte_if_data_transfer_status_is_OK);
461  RUN_TEST(UsbReadByte_unselects_the_FT221X);
462  RUN_TEST(UsbReadByte_returns_either_FtOK_if_pbyte_has_the_read_data_or_FtError_if_Usb_receive_buffer_was_empty);
463 
464  puts("## UsbWriteByte");
465  // TODO(sustainablelab): write tests
466  puts("FAIL: Implement Test");
467 
468  }
469 }
470 
471 void test_StatusCode(bool run_test)
472 {
473  if (run_test)
474  {
475  puts("# StatusCode tests");
476 
477  puts("## led_setting_is_valid");
478  setUp = EmptySetup;
479  tearDown = EmptyTeardown;
480  RUN_TEST(led_setting_is_valid_returns_TRUE_if_setting_is_OFF);
481  RUN_TEST(led_setting_is_valid_returns_TRUE_if_setting_is_GREEN);
482  RUN_TEST(led_setting_is_valid_returns_TRUE_if_setting_is_RED);
483  RUN_TEST(led_setting_is_valid_returns_FALSE_if_setting_is_any_other_value);
484 
485  }
486 }
487 
488 int main()
489 {
490  UNITY_BEGIN();
491  test_BiColorLed(Yep);
492  test_ReadWriteBits(Yep);
493  puts("# Flag test");
494  setUp = EmptySetup;
495  tearDown = EmptyTeardown;
496  RUN_TEST(test_Flag);
497  test_Spi(Yep);
498  test_SpiSlave(Yep);
499  test_SpiMaster(Yep);
500  test_Queue(Yep);
501  test_UartSpi(Yep);
502  test_Lis(Yep);
503  test_Usb(Yep);
504  test_StatusCode(Yep);
505 
506  return UNITY_END();
507 }
LisConfigs.h
See LisConfig.h for context.
Spi_SPSR
spi_ptr Spi_SPSR
SPI Status Register.
Definition: SpiSlave-HardwareFake.h:27
StatusCodes.h
See StatusCode.h for context.
Mock_s
Definition: Mock.c:5
Generated by doxygen 1.9.1