Mock for sleep and wdt

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Proper `ostream operator <<` for `nullptr`
 - Proper comparison operations fro `nullptr`
+- Mocks for avr/sleep.h and avr/wdt.h
+- Definitions for ISR and ADCSRA
 
 ### Changed
 - `Compare.h` heavily refactored to use a smallish macro

SampleProjects/TestSomething/test/adc.cpp

@@ -0,0 +1,10 @@
+#include <ArduinoUnitTests.h>
+#include <Arduino.h>
+
+unittest(check_ADCSRA_read_write) {
+  ADCSRA = 123;
+
+  assertEqual(123, ADCSRA);
+}
+
+unittest_main()

SampleProjects/TestSomething/test/isr_declaration.cpp

@@ -0,0 +1,8 @@
+#include <ArduinoUnitTests.h>
+#include <Arduino.h>
+
+// just check if declaration compiles
+ISR (WDT_vect) {
+}
+
+unittest_main()

SampleProjects/TestSomething/test/sleep.cpp

@@ -0,0 +1,65 @@
+#include <ArduinoUnitTests.h>
+#include <avr/sleep.h>
+
+GodmodeState* state = GODMODE();
+
+unittest(sleep_enable) {
+  state->reset();
+  assertFalse(state->sleep.sleep_enable);
+  assertEqual(0, state->sleep.sleep_enable_count);
+
+  sleep_enable();
+
+  assertTrue(state->sleep.sleep_enable);
+  assertEqual(1, state->sleep.sleep_enable_count);
+}
+
+unittest(sleep_disable) {
+  state->reset();
+  assertEqual(0, state->sleep.sleep_disable_count);
+
+  sleep_disable();
+
+  assertFalse(state->sleep.sleep_enable);
+  assertEqual(1, state->sleep.sleep_disable_count);
+}
+
+unittest(set_sleep_mode) {
+  state->reset();
+  assertEqual(0, state->sleep.sleep_mode);
+
+  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
+
+  assertEqual(SLEEP_MODE_PWR_DOWN, state->sleep.sleep_mode);
+}
+
+unittest(sleep_bod_disable) {
+  state->reset();
+  assertEqual(0, state->sleep.sleep_bod_disable_count);
+
+  sleep_bod_disable();
+
+  assertEqual(1, state->sleep.sleep_bod_disable_count);
+}
+
+unittest(sleep_cpu) {
+  state->reset();
+  assertEqual(0, state->sleep.sleep_cpu_count);
+
+  sleep_cpu();
+
+  assertEqual(1, state->sleep.sleep_cpu_count);
+}
+
+unittest(sleep_mode) {
+  state->reset();
+  assertEqual(0, state->sleep.sleep_mode_count);
+
+  sleep_mode();
+
+  assertEqual(1, state->sleep.sleep_mode_count);
+  assertEqual(1, state->sleep.sleep_enable_count);
+  assertEqual(1, state->sleep.sleep_disable_count);
+}
+
+unittest_main()

SampleProjects/TestSomething/test/wdt.cpp

@@ -0,0 +1,41 @@
+#include <ArduinoUnitTests.h>
+#include <avr/wdt.h>
+
+GodmodeState* state = GODMODE();
+
+unittest(taskWdtEnable_checkTimeout) {
+  state->reset();
+  assertEqual(0, state->wdt.timeout);
+
+  wdt_enable(WDTO_1S);
+
+  assertTrue(state->wdt.wdt_enable);
+  assertEqual(WDTO_1S, state->wdt.timeout);
+  assertEqual(1, state->wdt.wdt_enable_count);
+}
+
+unittest(taskWdtEnableDisable) {
+  state->reset();
+  assertEqual(0, state->wdt.wdt_enable_count);
+
+  wdt_enable(WDTO_1S);
+
+  assertTrue(state->wdt.wdt_enable);
+  assertEqual(1, state->wdt.wdt_enable_count);
+
+  wdt_disable();
+
+  assertFalse(state->wdt.wdt_enable);
+  assertEqual(1, state->wdt.wdt_enable_count);
+}
+
+unittest(wdt_reset) {
+  state->reset();
+  assertEqual(0, state->wdt.wdt_reset_count);
+
+  wdt_reset();
+
+  assertEqual(1, state->wdt.wdt_reset_count);
+}
+
+unittest_main()

cpp/arduino/Arduino.h

@@ -24,6 +24,9 @@ typedef uint8_t byte;
 // Math and Trig
 #include "AvrMath.h"
 
+#include "AvrAdc.h"
+#include "avr/interrupt.h"
+
 #include "Godmode.h"
 
 

cpp/arduino/AvrAdc.cpp

@@ -0,0 +1,4 @@
+#include "AvrAdc.h"
+
+// mock storage to allow access to ADCSRA
+unsigned char sfr_store;

cpp/arduino/AvrAdc.h

@@ -0,0 +1,8 @@
+#ifndef _AVR_ADC_H_
+#define _AVR_ADC_H_
+
+// mock storage to allow access to ADCSRA
+extern unsigned char sfr_store;
+#define _SFR_MEM8(mem_addr) sfr_store
+
+#endif // _AVR_ADC_H_

cpp/arduino/Godmode.h

@@ -43,6 +43,24 @@ class GodmodeState {
     uint8_t mode;
   };
 
+  struct SleepDef {
+    bool sleep_enable = false;
+    unsigned int sleep_enable_count = 0;
+    unsigned int sleep_disable_count = 0;
+    unsigned char sleep_mode = 0;
+    unsigned int sleep_cpu_count = 0;
+    unsigned int sleep_mode_count = 0;
+    unsigned int sleep_bod_disable_count = 0;
+  };
+
+  struct WdtDef {
+    bool wdt_enable = false;
+    unsigned char timeout = 0;
+    unsigned int wdt_enable_count = 0;
+    unsigned int wdt_disable_count = 0;
+    unsigned int wdt_reset_count = 0;
+  };
+
   public:
     unsigned long micros;
     unsigned long seed;
@@ -52,6 +70,8 @@ class GodmodeState {
     struct PortDef serialPort[NUM_SERIAL_PORTS];
     struct InterruptDef interrupt[MOCK_PINS_COUNT]; // not sure how to get actual number
     struct PortDef spi;
+    struct SleepDef sleep;
+    struct WdtDef wdt;
 
     void resetPins() {
       for (int i = 0; i < MOCK_PINS_COUNT; ++i) {
@@ -85,12 +105,32 @@ class GodmodeState {
       spi.readDelayMicros = 0;
     }
 
+    void resetSleep() {
+      sleep.sleep_enable = false;
+      sleep.sleep_enable_count = 0;
+      sleep.sleep_disable_count = 0;
+      sleep.sleep_mode = 0;
+      sleep.sleep_cpu_count = 0;
+      sleep.sleep_mode_count = 0;
+      sleep.sleep_bod_disable_count = 0;
+    }
+
+    void resetWdt() {
+      wdt.wdt_enable = false;
+      wdt.timeout = 0;
+      wdt.wdt_enable_count = 0;
+      wdt.wdt_disable_count = 0;
+      wdt.wdt_reset_count = 0;
+    }
+
     void reset() {
       resetClock();
       resetPins();
       resetInterrupts();
       resetPorts();
       resetSPI();
+      resetSleep();
+      resetWdt();
       seed = 1;
     }
 
@@ -114,7 +154,7 @@ int analogRead(uint8_t);
 void analogWrite(uint8_t, int);
 #define analogReadResolution(...) _NOP()
 #define analogWriteResolution(...) _NOP()
-void attachInterrupt(uint8_t interrupt, void ISR(void), uint8_t mode);
+void attachInterrupt(uint8_t interrupt, void isr(void), uint8_t mode);
 void detachInterrupt(uint8_t interrupt);
 
 // TODO: issue #26 to track the commanded state here

cpp/arduino/avr/interrupt.h

@@ -0,0 +1,10 @@
+#ifndef _AVR_INTERRUPT_H_
+#define _AVR_INTERRUPT_H_
+
+// allows the production code to define an ISR method
+#define _VECTOR(N) __vector_ ## N
+#define ISR(vector, ...)            \
+     extern "C" void vector (void)  __VA_ARGS__; \
+     void vector (void)
+
+#endif // _AVR_INTERRUPT_H_

cpp/arduino/avr/sleep.h

@@ -0,0 +1,40 @@
+#ifndef _AVR_SLEEP_H_
+#define _AVR_SLEEP_H_
+
+#include <Godmode.h>
+
+void sleep_enable() {
+  GodmodeState* godmode = GODMODE();
+  godmode->sleep.sleep_enable = true;
+  godmode->sleep.sleep_enable_count++;
+}
+
+void sleep_disable() {
+  GodmodeState* godmode = GODMODE();
+  godmode->sleep.sleep_enable = false;
+  godmode->sleep.sleep_disable_count++;
+}
+
+void set_sleep_mode(unsigned char mode) {
+  GodmodeState* godmode = GODMODE();
+  godmode->sleep.sleep_mode = mode;
+}
+
+void sleep_bod_disable() {
+  GodmodeState* godmode = GODMODE();
+  godmode->sleep.sleep_bod_disable_count++;
+}
+
+void sleep_cpu() {
+  GodmodeState* godmode = GODMODE();
+  godmode->sleep.sleep_cpu_count++;
+}
+
+void sleep_mode() {
+  GodmodeState* godmode = GODMODE();
+  sleep_enable();
+  godmode->sleep.sleep_mode_count++;
+  sleep_disable();
+}
+
+#endif /* _AVR_SLEEP_H_ */

cpp/arduino/avr/wdt.h

@@ -0,0 +1,35 @@
+#ifndef _AVR_WDT_H_
+#define _AVR_WDT_H_
+
+#include <Godmode.h>
+
+#define WDTO_15MS   0
+#define WDTO_30MS   1
+#define WDTO_60MS   2
+#define WDTO_120MS  3
+#define WDTO_250MS  4
+#define WDTO_500MS  5
+#define WDTO_1S     6
+#define WDTO_2S     7
+#define WDTO_4S     8
+#define WDTO_8S     9
+
+void wdt_enable(unsigned char timeout) {
+  GodmodeState* godmode = GODMODE();
+  godmode->wdt.wdt_enable = true;
+  godmode->wdt.timeout = timeout;
+  godmode->wdt.wdt_enable_count++;
+}
+
+void wdt_disable() {
+  GodmodeState* godmode = GODMODE();
+  godmode->wdt.wdt_enable = false;
+  godmode->wdt.wdt_disable_count++;
+}
+
+void wdt_reset() {
+  GodmodeState* godmode = GODMODE();
+  godmode->wdt.wdt_reset_count++;
+}
+
+#endif /* _AVR_WDT_H_ */