Cleanup project structure. Update unit test Makefile to place object

files in obj/test

src/test/Makefile

@@ -0,0 +1,139 @@
+# A sample Makefile for building Google Test and using it in user
+# tests.  Please tweak it to suit your environment and project.  You
+# may want to move it to your project's root directory.
+#
+# SYNOPSIS:
+#
+#   make [all]  - makes everything.
+#   make TARGET - makes the given target.
+#   make clean  - removes all files generated by make.
+
+# Please tweak the following variable definitions as needed by your
+# project, except GTEST_HEADERS, which you can use in your own targets
+# but shouldn't modify.
+
+# Points to the root of Google Test, relative to where this file is.
+# Remember to tweak this if you move this file.
+GTEST_DIR = ../../lib/test/gtest
+
+# Where to find user code.
+USER_DIR = ../main
+TEST_DIR = unit
+USER_INCLUDE_DIR = $(USER_DIR)
+
+OBJECT_DIR = ../../obj/test
+
+# Flags passed to the preprocessor.
+# Set Google Test's header directory as a system directory, such that
+# the compiler doesn't generate warnings in Google Test headers.
+CPPFLAGS += -isystem $(GTEST_DIR)/inc
+
+# Flags passed to the C++ compiler.
+CXXFLAGS += -g -Wall -Wextra -pthread -ggdb -O0
+
+# All tests produced by this Makefile.  Remember to add new tests you
+# created to the list.
+TESTS = battery_unittest flight_imu_unittest gps_conversion_unittest telemetry_hott_unittest
+
+# All Google Test headers.  Usually you shouldn't change this
+# definition.
+GTEST_HEADERS = $(GTEST_DIR)/inc/gtest/*.h
+
+# House-keeping build targets.
+
+all : $(TESTS)
+
+clean :
+	rm -rf $(TESTS) $(OBJECT_DIR)
+
+# Builds gtest.a and gtest_main.a.
+
+# Usually you shouldn't tweak such internal variables, indicated by a
+# trailing _.
+GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/inc/gtest/*.h $(GTEST_HEADERS)
+
+# For simplicity and to avoid depending on Google Test's
+# implementation details, the dependencies specified below are
+# conservative and not optimized.  This is fine as Google Test
+# compiles fast and for ordinary users its source rarely changes.
+$(OBJECT_DIR)/gtest-all.o : $(GTEST_SRCS_)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
+            $(GTEST_DIR)/src/gtest-all.cc -o $@
+
+$(OBJECT_DIR)/gtest_main.o : $(GTEST_SRCS_)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
+            $(GTEST_DIR)/src/gtest_main.cc -o $@
+
+$(OBJECT_DIR)/gtest.a : $(OBJECT_DIR)/gtest-all.o
+	$(AR) $(ARFLAGS) $@ $^
+
+$(OBJECT_DIR)/gtest_main.a : $(OBJECT_DIR)/gtest-all.o $(OBJECT_DIR)/gtest_main.o
+	$(AR) $(ARFLAGS) $@ $^
+
+# Builds a sample test.  A test should link with either gtest.a or
+# gtest_main.a, depending on whether it defines its own main()
+# function.
+
+# includes in test dir must override includes in user dir
+TEST_INCLUDE_DIRS := $(TEST_DIR) \
+	$(USER_INCLUDE_DIR)
+	
+
+TEST_CFLAGS	 = $(addprefix -I,$(TEST_INCLUDE_DIRS))
+
+
+$(OBJECT_DIR)/io/battery.o : $(USER_DIR)/io/battery.c $(USER_DIR)/io/battery.h $(GTEST_HEADERS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(TEST_CFLAGS) -c $(USER_DIR)/io/battery.c -o $@
+
+$(OBJECT_DIR)/battery_unittest.o : $(TEST_DIR)/battery_unittest.cc \
+                     $(USER_DIR)/io/battery.h $(GTEST_HEADERS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(TEST_CFLAGS) -c $(TEST_DIR)/battery_unittest.cc -o $@
+
+battery_unittest : $(OBJECT_DIR)/io/battery.o $(OBJECT_DIR)/battery_unittest.o $(OBJECT_DIR)/gtest_main.a
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $(OBJECT_DIR)/$@
+
+
+
+
+$(OBJECT_DIR)/flight/imu.o : $(USER_DIR)/flight/imu.c $(USER_DIR)/flight/imu.h $(GTEST_HEADERS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(TEST_CFLAGS) -c $(USER_DIR)/flight/imu.c -o $@
+
+$(OBJECT_DIR)/flight_imu_unittest.o : $(TEST_DIR)/flight_imu_unittest.cc \
+                     $(USER_DIR)/flight/imu.h $(GTEST_HEADERS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(TEST_CFLAGS) -c $(TEST_DIR)/flight_imu_unittest.cc -o $@
+
+flight_imu_unittest : $(OBJECT_DIR)/flight/imu.o $(OBJECT_DIR)/flight_imu_unittest.o $(OBJECT_DIR)/gtest_main.a
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $(OBJECT_DIR)/$@
+
+
+$(OBJECT_DIR)/io/gps_conversion.o : $(USER_DIR)/io/gps_conversion.c $(USER_DIR)/io/gps_conversion.h $(GTEST_HEADERS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(TEST_CFLAGS) -c $(USER_DIR)/io/gps_conversion.c -o $@
+
+$(OBJECT_DIR)/gps_conversion_unittest.o : $(TEST_DIR)/gps_conversion_unittest.cc \
+                     $(USER_DIR)/io/gps_conversion.h $(GTEST_HEADERS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(TEST_CFLAGS) -c $(TEST_DIR)/gps_conversion_unittest.cc -o $@
+
+gps_conversion_unittest : $(OBJECT_DIR)/io/gps_conversion.o $(OBJECT_DIR)/gps_conversion_unittest.o $(OBJECT_DIR)/gtest_main.a
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $(OBJECT_DIR)/$@
+
+
+
+$(OBJECT_DIR)/telemetry/hott.o : $(USER_DIR)/telemetry/hott.c $(USER_DIR)/telemetry/hott.h $(GTEST_HEADERS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(TEST_CFLAGS) -c $(USER_DIR)/telemetry/hott.c -o $@
+
+$(OBJECT_DIR)/telemetry_hott_unittest.o : $(TEST_DIR)/telemetry_hott_unittest.cc \
+                     $(USER_DIR)/telemetry/hott.h $(GTEST_HEADERS)
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(TEST_CFLAGS) -c $(TEST_DIR)/telemetry_hott_unittest.cc -o $@
+
+telemetry_hott_unittest :$(OBJECT_DIR)/telemetry/hott.o $(OBJECT_DIR)/telemetry_hott_unittest.o $(OBJECT_DIR)/io/gps_conversion.o $(OBJECT_DIR)/gtest_main.a
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $(OBJECT_DIR)/$@

src/test/unit/battery_unittest.cc

@@ -0,0 +1,59 @@
+#include <stdint.h>
+
+#include <limits.h>
+#include "io/battery.h"
+
+#include "unittest_macros.h"
+#include "gtest/gtest.h"
+
+typedef struct batteryAdcToVoltageExpectation_s {
+    uint16_t adcReading;
+    uint16_t expectedVoltageInDeciVoltSteps;
+} batteryAdcToVoltageExpectation_t;
+
+#define ELEVEN_TO_ONE_VOLTAGE_DIVIDER 110 // (10k:1k) * 10 for 0.1V
+
+TEST(BatteryTest, BatteryADCToVoltage)
+{
+    // given
+
+    batteryConfig_t batteryConfig;
+    batteryConfig.vbatscale = ELEVEN_TO_ONE_VOLTAGE_DIVIDER;
+
+    batteryInit(&batteryConfig);
+
+    batteryAdcToVoltageExpectation_t batteryAdcToVoltageExpectations[] = {
+            {1420, 125},
+            {1430, 126},
+            {1440, 127},
+            {1890, 167},
+            {1900, 168},
+            {1910, 169}
+    };
+    uint8_t testIterationCount = sizeof(batteryAdcToVoltageExpectations) / sizeof(batteryAdcToVoltageExpectation_t);
+
+    // expect
+
+    for (uint8_t index = 0; index < testIterationCount; index ++) {
+        batteryAdcToVoltageExpectation_t *batteryAdcToVoltageExpectation = &batteryAdcToVoltageExpectations[index];
+        printf("adcReading: %d\n", batteryAdcToVoltageExpectation->adcReading);
+
+        uint16_t pointOneVoltSteps = batteryAdcToVoltage(batteryAdcToVoltageExpectation->adcReading);
+
+        EXPECT_EQ(pointOneVoltSteps, batteryAdcToVoltageExpectation->expectedVoltageInDeciVoltSteps);
+    }
+}
+
+// STUBS
+
+uint16_t adcGetChannel(uint8_t channel)
+{
+    UNUSED(channel);
+    return 0;
+}
+
+void delay(uint32_t ms)
+{
+    UNUSED(ms);
+    return;
+}

src/test/unit/flight_imu_unittest.cc

@@ -0,0 +1,119 @@
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <limits.h>
+
+#define BARO
+
+
+// FIXME this giant list of includes (below) and stubs (bottom) indicates there is too much going on in flight_imu.c and that it needs decoupling and breaking up.
+
+#include "common/axis.h"
+#include "flight/flight.h"
+
+#include "sensors/sensors.h"
+#include "drivers/accgyro.h"
+#include "sensors/gyro.h"
+#include "sensors/compass.h"
+#include "sensors/acceleration.h"
+#include "sensors/barometer.h"
+
+#include "io/gps.h"
+
+#include "io/gimbal.h"
+#include "flight/mixer.h"
+
+// FIXME remove dependency on config.h
+#include "sensors/boardalignment.h"
+#include "io/battery.h"
+#include "io/escservo.h"
+#include "io/rc_controls.h"
+#include "rx/rx.h"
+#include "drivers/serial.h"
+#include "io/serial.h"
+#include "telemetry/telemetry.h"
+#include "flight/failsafe.h"
+#include "config/runtime_config.h"
+#include "config/config.h"
+#include "config/config_profile.h"
+#include "config/config_master.h"
+
+
+#include "flight/imu.h"
+
+#include "unittest_macros.h"
+#include "gtest/gtest.h"
+
+#define DOWNWARDS_THRUST true
+#define UPWARDS_THRUST false
+
+
+bool isThrustFacingDownwards(rollAndPitchInclination_t *inclinations);
+
+typedef struct inclinationExpectation_s {
+    rollAndPitchInclination_t inclination;
+    bool expectDownwardsThrust;
+} inclinationExpectation_t;
+
+TEST(FlightImuTest, IsThrustFacingDownwards)
+{
+    // given
+
+    inclinationExpectation_t inclinationExpectations[] = {
+            { { 0, 0 }, DOWNWARDS_THRUST },
+            { { 799, 799 }, DOWNWARDS_THRUST },
+            { { 800, 799 }, UPWARDS_THRUST },
+            { { 799, 800 }, UPWARDS_THRUST },
+            { { 800, 800 }, UPWARDS_THRUST },
+            { { 801, 801 }, UPWARDS_THRUST },
+            { { -799, -799 }, DOWNWARDS_THRUST },
+            { { -800, -799 }, UPWARDS_THRUST },
+            { { -799, -800 }, UPWARDS_THRUST },
+            { { -800, -800 }, UPWARDS_THRUST },
+            { { -801, -801 }, UPWARDS_THRUST }
+    };
+    uint8_t testIterationCount = sizeof(inclinationExpectations) / sizeof(inclinationExpectation_t);
+
+    // expect
+
+    for (uint8_t index = 0; index < testIterationCount; index ++) {
+        inclinationExpectation_t *angleInclinationExpectation = &inclinationExpectations[index];
+        printf("iteration: %d\n", index);
+        bool result = isThrustFacingDownwards(&angleInclinationExpectation->inclination);
+        EXPECT_EQ(angleInclinationExpectation->expectDownwardsThrust, result);
+    }
+}
+
+// STUBS
+
+uint16_t acc_1G;
+profile_t currentProfile;
+master_t masterConfig;
+int16_t heading;
+flags_t f;
+gyro_t gyro;
+int16_t magADC[XYZ_AXIS_COUNT];
+int32_t BaroAlt;
+
+void gyroGetADC(void) {};
+bool sensors(uint32_t mask)
+{
+    UNUSED(mask);
+    return false;
+};
+void updateAccelerationReadings(rollAndPitchTrims_t *rollAndPitchTrims)
+{
+    UNUSED(rollAndPitchTrims);
+}
+
+uint32_t micros(void) { return 0; }
+bool isBaroCalibrationComplete(void) { return true; }
+void performBaroCalibrationCycle(void) {}
+int32_t baroCalculateAltitude(void) { return 0; }
+int constrain(int amt, int low, int high)
+{
+    UNUSED(amt);
+    UNUSED(low);
+    UNUSED(high);
+    return 0;
+}

src/test/unit/gps_conversion_unittest.cc

@@ -0,0 +1,52 @@
+#include <stdint.h>
+
+#include <limits.h>
+#include "io/gps_conversion.h"
+
+#include "unittest_macros.h"
+#include "gtest/gtest.h"
+
+// See http://en.wikipedia.org/wiki/Geographic_coordinate_conversion
+
+TEST(GpsConversionTest, GPSCoordToDegrees_BadString)
+{
+    // expect
+    uint32_t result = GPS_coord_to_degrees("diediedie");
+    EXPECT_EQ(result, 0);
+}
+
+typedef struct gpsConversionExpectation_s {
+    char *coord;
+    uint32_t degrees;
+} gpsConversionExpectation_t;
+
+TEST(GpsConversionTest, GPSCoordToDegrees_NMEA_Values)
+{
+    gpsConversionExpectation_t gpsConversionExpectations[] = {
+        {"0.0", 0},
+        {"000.0", 0},
+        {"00000.0000", 0},
+        {"0.0001", 16}, // smallest value
+        {"25599.9999", 2566666650UL}, // largest value
+        {"25599.99999", 2566666650UL}, // too many fractional digits
+        {"25699.9999", 16666650UL}, // overflowed without detection
+        {"5128.3727", 514728783UL},
+        {"5321.6802", 533613366UL},
+        {"00630.3372", 65056200UL},
+    };
+
+    // expect
+
+    uint8_t testIterationCount = sizeof(gpsConversionExpectations) / sizeof(gpsConversionExpectation_t);
+
+    // expect
+
+    for (uint8_t index = 0; index < testIterationCount; index ++) {
+        gpsConversionExpectation_t *expectation = &gpsConversionExpectations[index];
+        printf("iteration: %d\n", index);
+
+        uint32_t result = GPS_coord_to_degrees(expectation->coord);
+        EXPECT_EQ(result, expectation->degrees);
+    }
+}
+

src/test/unit/platform.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#define BARO

src/test/unit/telemetry_hott_unittest.cc

@@ -0,0 +1,203 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <limits.h>
+
+#include "platform.h"
+
+#include "common/axis.h"
+
+#include "drivers/system.h"
+
+#include "drivers/serial.h"
+#include "io/serial.h"
+
+#include "config/runtime_config.h"
+
+#include "sensors/sensors.h"
+
+#include "flight/flight.h"
+#include "io/gps.h"
+#include "io/battery.h"
+
+#include "telemetry/telemetry.h"
+#include "telemetry/hott.h"
+
+#include "io/gps_conversion.h"
+
+
+#include "unittest_macros.h"
+#include "gtest/gtest.h"
+
+void addGPSCoordinates(HOTT_GPS_MSG_t *hottGPSMessage, int32_t latitude, int32_t longitude);
+
+// See http://en.wikipedia.org/wiki/Geographic_coordinate_conversion
+
+HOTT_GPS_MSG_t hottGPSMessage;
+
+HOTT_GPS_MSG_t *getGPSMessageForTest(void)
+{
+    memset(&hottGPSMessage, 0, sizeof(hottGPSMessage));
+    return &hottGPSMessage;
+}
+
+TEST(TelemetryHottTest, UpdateGPSCoordinates1)
+{
+    // given
+    HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
+
+    // Mayrhofen, Austria
+    uint32_t longitude = GPS_coord_to_degrees("4710.5186");
+    uint32_t latitude = GPS_coord_to_degrees("1151.4252");
+
+    // when
+    addGPSCoordinates(hottGPSMessage, latitude, longitude);
+
+    // then
+    EXPECT_EQ(hottGPSMessage->pos_NS, 0);
+    EXPECT_EQ(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L, 1151);
+    EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L), 4251);
+
+    EXPECT_EQ(hottGPSMessage->pos_EW, 0);
+    EXPECT_EQ(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L, 4710);
+    EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), 5186);
+}
+
+TEST(TelemetryHottTest, UpdateGPSCoordinates2)
+{
+    // given
+    HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
+
+    // Hampstead Heath, London
+    // 51.563886, -0.159960
+    int32_t longitude = GPS_coord_to_degrees("5156.3886");
+    int32_t latitude  = -GPS_coord_to_degrees("015.9960");
+
+    // when
+    addGPSCoordinates(hottGPSMessage, longitude, latitude);
+
+    // then
+    EXPECT_EQ(hottGPSMessage->pos_NS, 0);
+    EXPECT_EQ(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L, 5156);
+    EXPECT_EQ(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L, 3886);
+
+    EXPECT_EQ(hottGPSMessage->pos_EW, 1);
+    EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L), -15);
+    EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), -9960);
+}
+
+
+TEST(TelemetryHottTest, UpdateGPSCoordinates3)
+{
+    // given
+    HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
+
+    int32_t longitude = -GPS_coord_to_degrees("17999.9999");
+    int32_t latitude = GPS_coord_to_degrees("8999.9999");
+
+    // when
+    addGPSCoordinates(hottGPSMessage, longitude, latitude);
+
+    // then
+    EXPECT_EQ(hottGPSMessage->pos_NS, 1);
+    EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_dm_H << 8 | hottGPSMessage->pos_NS_dm_L), -18039);
+    EXPECT_EQ((int16_t)(hottGPSMessage->pos_NS_sec_H << 8 | hottGPSMessage->pos_NS_sec_L), -9999);
+
+    EXPECT_EQ(hottGPSMessage->pos_EW, 0);
+    EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_dm_H << 8 | hottGPSMessage->pos_EW_dm_L), 9039);
+    EXPECT_EQ((int16_t)(hottGPSMessage->pos_EW_sec_H << 8 | hottGPSMessage->pos_EW_sec_L), 9999);
+}
+
+TEST(TelemetryHottTest, PrepareGPSMessage_Altitude1m)
+{
+    // given
+    HOTT_GPS_MSG_t *hottGPSMessage = getGPSMessageForTest();
+
+    f.GPS_FIX = 1;
+    uint16_t altitudeInMeters = 1;
+    GPS_altitude = altitudeInMeters * (1 / 0.1f); // 1 = 0.1m
+
+    // when
+    hottPrepareGPSResponse(hottGPSMessage);
+
+    // then
+    EXPECT_EQ((int16_t)(hottGPSMessage->altitude_H << 8 | hottGPSMessage->altitude_L), 1 + HOTT_GPS_ALTITUDE_OFFSET);
+}
+
+
+// STUBS
+
+int16_t debug[4];
+
+uint8_t GPS_numSat;
+flags_t f;
+int32_t GPS_coord[2];
+uint16_t GPS_speed;                 // speed in 0.1m/s
+uint16_t GPS_distanceToHome;        // distance to home point in meters
+uint16_t GPS_altitude;              // altitude in 0.1m
+uint8_t vbat;
+int16_t GPS_directionToHome;        // direction to home or hol point in degrees
+
+uint32_t micros(void) { return 0; }
+
+uint8_t serialTotalBytesWaiting(serialPort_t *instance) {
+    UNUSED(instance);
+    return 0;
+}
+
+uint8_t serialRead(serialPort_t *instance) {
+    UNUSED(instance);
+    return 0;
+}
+
+void serialWrite(serialPort_t *instance, uint8_t ch) {
+    UNUSED(instance);
+    UNUSED(ch);
+}
+
+void serialSetMode(serialPort_t *instance, portMode_t mode) {
+    UNUSED(instance);
+    UNUSED(mode);
+}
+
+void serialSetBaudRate(serialPort_t *instance, uint32_t baudRate) {
+    UNUSED(instance);
+    UNUSED(baudRate);
+}
+
+void beginSerialPortFunction(serialPort_t *port, serialPortFunction_e function) {
+    UNUSED(port);
+    UNUSED(function);
+}
+
+void endSerialPortFunction(serialPort_t *port, serialPortFunction_e function) {
+    UNUSED(port);
+    UNUSED(function);
+}
+
+serialPort_t *openSerialPort(serialPortFunction_e functionMask, serialReceiveCallbackPtr callback, uint32_t baudRate, portMode_t mode, serialInversion_e inversion) {
+    UNUSED(functionMask);
+    UNUSED(baudRate);
+    UNUSED(callback);
+    UNUSED(mode);
+    UNUSED(inversion);
+
+    return NULL;
+}
+
+serialPort_t *findOpenSerialPort(uint16_t functionMask) {
+    UNUSED(functionMask);
+    return NULL;
+}
+
+bool sensors(uint32_t mask) {
+    UNUSED(mask);
+    return false;
+}
+
+
+
+
+
+

src/test/unit/unittest_macros.h

@@ -0,0 +1,4 @@
+#pragma once
+
+
+#define UNUSED(x) (void)(x)