Add mocks and suggested unit test sequence.

Author: schmonz

Makefile

@@ -8,6 +8,7 @@ THE_PROGRAM	=  do_toggle
 TARGET_SYSTEM	?= ${DEFAULT_SYSTEM}
 ifeq (rpi, ${TARGET_SYSTEM})
 MAKE_TARGET	=  deploy
+DEPLOY_COMMAND	?= scp ${THE_PROGRAM} pet-piercer.local:
 EXT_TREES_ROOT	?= ${HOME}/Documents/trees
 NETBSDSRCDIR	?= ${EXT_TREES_ROOT}/netbsd-src
 CROSS_ROOT	?= ${EXT_TREES_ROOT}/rpi
@@ -48,12 +49,12 @@ clean:
 	${SILENT}rm -rf *.dSYM *.gcda *.gcno *.gcov
 
 deploy: ${THE_PROGRAM}
-	${SILENT}scp ${THE_PROGRAM} pet-piercer.local:
+	${SILENT}${DEPLOY_COMMAND}
 
 .PHONY: all check clean deploy
 
-${THE_TESTS}: ${THE_PROGRAM} .has_check ${THE_LIBRARY} check_toggle.c check_toggle_acceptance.c check_toggle_unit.c
-	${SILENT}${CC} ${CFLAGS} ${CHECK_CFLAGS} -o ${THE_TESTS} check_toggle_acceptance.c check_toggle_unit.c check_toggle.c ${CHECK_LIBS} ${TEST_LIBS} ${THE_LIBRARY}
+${THE_TESTS}: ${THE_PROGRAM} .has_check ${THE_LIBRARY} check_toggle.c acceptance.c unit.c
+	${SILENT}${CC} ${CFLAGS} ${CHECK_CFLAGS} -o ${THE_TESTS} acceptance.c unit.c check_toggle.c ${CHECK_LIBS} ${TEST_LIBS} ${THE_LIBRARY}
 
 ${THE_LIBRARY}: led.h led.c syscalls.h ${TARGET_SYSTEM}_syscalls.h ${TARGET_SYSTEM}_syscalls.c
 	${SILENT}${CC} ${CFLAGS} -c led.c

check_toggle_acceptance.c renamed to acceptance.c

@@ -2,14 +2,14 @@
 
 #include "led.h"
 
-START_TEST(test_acceptance_nothing) {
-    ck_assert_int_eq(1, 2);
+START_TEST(test_public_interface) {
+    led_toggle();
 } END_TEST
 
 TCase* tcase_acceptance(void) {
     TCase *tc = tcase_create("Acceptance Tests");
 
-    tcase_add_test(tc, test_acceptance_nothing);
+    tcase_add_test(tc, test_public_interface);
 
     return tc;
 }

check_toggle_unit.c

@@ -0,0 +1,100 @@
+#include <limits.h>
+#include <string.h>
+
+#include "host_syscalls.h"
+
+
+static struct {
+    int  fake_return_value;
+    int  spy_numcalls;
+    char spy_path[PATH_MAX];
+    int  spy_oflag;
+} mock_open;
+
+void mock_open_fake_return_value(int value) {
+    mock_open.fake_return_value = value;
+}
+
+int mock_open_spy_numcalls() {
+    return mock_open.spy_numcalls;
+}
+
+int mock_open_spy_oflag() {
+    return mock_open.spy_oflag;
+}
+
+const char * mock_open_spy_path() {
+    return mock_open.spy_path;
+}
+
+int open(const char *path, int oflag, ...) {
+    strcpy(mock_open.spy_path, path);
+    mock_open.spy_oflag = oflag;
+    ++mock_open.spy_numcalls;
+    return mock_open.fake_return_value;
+}
+
+
+static struct {
+    int  fake_return_value;
+    int  spy_numcalls;
+    int  spy_fd;
+    int  spy_request;
+    int  spy_pin;
+} mock_ioctl;
+
+void mock_ioctl_fake_return_value(int value) {
+    mock_ioctl.fake_return_value = value;
+}
+
+int mock_ioctl_spy_fd() {
+    return mock_ioctl.spy_fd;
+}
+
+int mock_ioctl_spy_numcalls() {
+    return mock_ioctl.spy_numcalls;
+}
+
+int mock_ioctl_spy_request() {
+    return mock_ioctl.spy_request;
+}
+
+int mock_ioctl_spy_pin() {
+    return mock_ioctl.spy_pin;
+}
+
+int ioctl(int fildes, unsigned long request, void *gpio_request) {
+    (void)fildes;
+    mock_ioctl.spy_fd = fildes;
+    mock_ioctl.spy_request = request;
+    mock_ioctl.spy_pin = ((struct gpio_req *)gpio_request)->gp_pin;
+    ++mock_ioctl.spy_numcalls;
+    return mock_ioctl.fake_return_value;
+}
+
+
+static struct {
+    int  spy_numcalls;
+    int  spy_fd;
+} mock_close;
+
+int mock_close_spy_numcalls() {
+    return mock_close.spy_numcalls;
+}
+
+int mock_close_spy_fd() {
+    return mock_close.spy_fd;
+}
+
+int close(int fildes) {
+    mock_close.spy_fd = fildes;
+    ++mock_close.spy_numcalls;
+    return 99;
+}
+
+
+void mock_reset_all() {
+    memset(&mock_open, 0, sizeof(mock_open));
+    memset(&mock_ioctl, 0, sizeof(mock_ioctl));
+    memset(&mock_close, 0, sizeof(mock_close));
+}

host_syscalls.c

@@ -0,0 +1,23 @@
+void mock_reset_all(void);
+
+int open(const char *, int, ...);
+#define O_WRONLY 77
+void mock_open_fake_return_value(int);
+int mock_open_spy_numcalls(void);
+const char* mock_open_spy_path(void);
+int mock_open_spy_oflag(void);
+
+int ioctl(int, unsigned long, void *);
+#define GPIOTOGGLE 66
+struct gpio_req {
+    int gp_pin;
+};
+void mock_ioctl_fake_return_value(int);
+int mock_ioctl_spy_numcalls(void);
+int mock_ioctl_spy_fd(void);
+int mock_ioctl_spy_request(void);
+int mock_ioctl_spy_pin(void);
+
+int close(int);
+int mock_close_spy_numcalls(void);
+int mock_close_spy_fd(void);

host_syscalls.h

@@ -0,0 +1,53 @@
+#include <check.h>
+
+#include "led.h"
+#include "syscalls.h"
+
+START_TEST(it_opens_gpio_device_for_write) {
+    ck_assert_int_eq(mock_open_spy_numcalls(), 0);
+    ck_assert_str_eq(mock_open_spy_path(), "");
+    ck_assert_int_eq(mock_open_spy_oflag(), 0);
+
+    led_toggle();
+
+    ck_assert_int_eq(mock_open_spy_numcalls(), 1);
+    ck_assert_str_eq(mock_open_spy_path(), "/dev/gpio0");
+    ck_assert_int_eq(mock_open_spy_oflag(), O_WRONLY);
+} END_TEST
+
+START_TEST(it_stops_if_open_fails) {
+} END_TEST
+
+START_TEST(it_calls_ioctl_if_open_succeeds) {
+} END_TEST
+
+START_TEST(it_ioctls_gpio_device_to_toggle_our_pin) {
+} END_TEST
+
+START_TEST(it_closes_gpio_device_if_ioctl_succeeds) {
+} END_TEST
+
+START_TEST(it_closes_gpio_device_if_ioctl_fails) {
+} END_TEST
+
+void setup(void) {
+    mock_reset_all();
+}
+
+void teardown(void) {
+}
+
+TCase* tcase_unit(void) {
+    TCase *tc = tcase_create("Unit Tests");
+
+    tcase_add_checked_fixture(tc, setup, teardown);
+
+    tcase_add_test(tc, it_opens_gpio_device_for_write);
+    tcase_add_test(tc, it_stops_if_open_fails);
+    tcase_add_test(tc, it_calls_ioctl_if_open_succeeds);
+    tcase_add_test(tc, it_ioctls_gpio_device_to_toggle_our_pin);
+    tcase_add_test(tc, it_closes_gpio_device_if_ioctl_succeeds);
+    tcase_add_test(tc, it_closes_gpio_device_if_ioctl_fails);
+
+    return tc;
+}