src/test/unit/cli_unittest.cc

   1 /*
   2  * This file is part of Cleanflight.
   3  *
   4  * Cleanflight is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * Cleanflight is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with Cleanflight.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <stdint.h>
  19 #include <stdbool.h>
  20 #include <stdio.h>
  21
  22 #include <limits.h>
  23
  24 #include <math.h>
  25
  26 extern "C" {
  27     #include "platform.h"
  28     #include "target.h"
  29     #include "build/version.h"
  30     #include "pg/pg.h"
  31     #include "config/feature.h"
  32     #include "pg/pg_ids.h"
  33     #include "drivers/buf_writer.h"
  34     #include "drivers/vtx_common.h"
  35     #include "fc/config.h"
  36     #include "fc/rc_adjustments.h"
  37     #include "fc/runtime_config.h"
  38     #include "flight/mixer.h"
  39     #include "flight/pid.h"
  40     #include "flight/servos.h"
  41     #include "interface/cli.h"
  42     #include "interface/msp.h"
  43     #include "interface/msp_box.h"
  44     #include "interface/settings.h"
  45     #include "io/beeper.h"
  46     #include "io/ledstrip.h"
  47     #include "io/osd.h"
  48     #include "io/serial.h"
  49     #include "io/vtx.h"
  50     #include "pg/beeper.h"
  51     #include "rx/rx.h"
  52     #include "scheduler/scheduler.h"
  53     #include "sensors/battery.h"
  54
  55     void cliSet(char *cmdline);
  56     void cliGet(char *cmdline);
  57
  58     const clivalue_t valueTable[] = {
  59         { "array_unit_test",             VAR_INT8  | MODE_ARRAY | MASTER_VALUE, .config.array.length = 3, PG_RESERVED_FOR_TESTING_1, 0 }
  60     };
  61     const uint16_t valueTableEntryCount = ARRAYLEN(valueTable);
  62     const lookupTableEntry_t lookupTables[] = {};
  63
  64
  65     PG_REGISTER(osdConfig_t, osdConfig, PG_OSD_CONFIG, 0);
  66     PG_REGISTER(batteryConfig_t, batteryConfig, PG_BATTERY_CONFIG, 0);
  67     PG_REGISTER(ledStripConfig_t, ledStripConfig, PG_LED_STRIP_CONFIG, 0);
  68     PG_REGISTER(systemConfig_t, systemConfig, PG_SYSTEM_CONFIG, 0);
  69     PG_REGISTER(pilotConfig_t, pilotConfig, PG_PILOT_CONFIG, 0);
  70     PG_REGISTER_ARRAY(adjustmentRange_t, MAX_ADJUSTMENT_RANGE_COUNT, adjustmentRanges, PG_ADJUSTMENT_RANGE_CONFIG, 0);
  71     PG_REGISTER_ARRAY(modeActivationCondition_t, MAX_MODE_ACTIVATION_CONDITION_COUNT, modeActivationConditions, PG_MODE_ACTIVATION_PROFILE, 0);
  72     PG_REGISTER(mixerConfig_t, mixerConfig, PG_MIXER_CONFIG, 0);
  73     PG_REGISTER_ARRAY(motorMixer_t, MAX_SUPPORTED_MOTORS, customMotorMixer, PG_MOTOR_MIXER, 0);
  74     PG_REGISTER_ARRAY(servoParam_t, MAX_SUPPORTED_SERVOS, servoParams, PG_SERVO_PARAMS, 0);
  75     PG_REGISTER_ARRAY(servoMixer_t, MAX_SERVO_RULES, customServoMixers, PG_SERVO_MIXER, 0);
  76     PG_REGISTER(beeperConfig_t, beeperConfig, PG_BEEPER_CONFIG, 0);
  77     PG_REGISTER(rxConfig_t, rxConfig, PG_RX_CONFIG, 0);
  78     PG_REGISTER(serialConfig_t, serialConfig, PG_SERIAL_CONFIG, 0);
  79     PG_REGISTER_ARRAY(rxChannelRangeConfig_t, NON_AUX_CHANNEL_COUNT, rxChannelRangeConfigs, PG_RX_CHANNEL_RANGE_CONFIG, 0);
  80     PG_REGISTER_ARRAY(rxFailsafeChannelConfig_t, MAX_SUPPORTED_RC_CHANNEL_COUNT, rxFailsafeChannelConfigs, PG_RX_FAILSAFE_CHANNEL_CONFIG, 0);
  81     PG_REGISTER(pidConfig_t, pidConfig, PG_PID_CONFIG, 0);
  82
  83     PG_REGISTER_WITH_RESET_FN(int8_t, unitTestData, PG_RESERVED_FOR_TESTING_1, 0);
  84 }
  85
  86 #include "unittest_macros.h"
  87 #include "gtest/gtest.h"
  88 TEST(CLIUnittest, TestCliSet)
  89 {
  90
  91     cliSet((char *)"array_unit_test    =   123,  -3  , 1");
  92
  93     const clivalue_t cval = {
  94         .name = "array_unit_test",
  95         .type = MODE_ARRAY | MASTER_VALUE | VAR_INT8,
  96         .pgn = PG_RESERVED_FOR_TESTING_1,
  97         .offset = 0
  98     };
  99
 100     printf("\n===============================\n");
 101     int8_t *data = (int8_t *)cliGetValuePointer(&cval);
 102     for(int i=0; i<3; i++){
 103         printf("data[%d] = %d\n", i, data[i]);
 104     }
 105     printf("\n===============================\n");
 106
 107
 108     EXPECT_EQ(123, data[0]);
 109     EXPECT_EQ( -3, data[1]);
 110     EXPECT_EQ(  1, data[2]);
 111
 112
 113     //cliGet((char *)"osd_item_vbat");
 114     //EXPECT_EQ(false, false);
 115 }
 116
 117 // STUBS
 118 extern "C" {
 119
 120 float motor_disarmed[MAX_SUPPORTED_MOTORS];
 121
 122 uint16_t batteryWarningVoltage;
 123 uint8_t useHottAlarmSoundPeriod (void) { return 0; }
 124 const uint32_t baudRates[] = {0, 9600, 19200, 38400, 57600, 115200, 230400, 250000, 400000}; // see baudRate_e
 125
 126 uint32_t micros(void) {return 0;}
 127
 128 int32_t getAmperage(void) {
 129     return 100;
 130 }
 131
 132 uint16_t getBatteryVoltage(void) {
 133     return 42;
 134 }
 135
 136 batteryState_e getBatteryState(void) {
 137     return BATTERY_OK;
 138 }
 139
 140 uint8_t calculateBatteryPercentageRemaining(void) {
 141     return 67;
 142 }
 143
 144 uint8_t getMotorCount() {
 145     return 4;
 146 }
 147
 148
 149 void setPrintfSerialPort(struct serialPort_s) {}
 150
 151 void tfp_printf(const char * expectedFormat, ...) {
 152     va_list args;
 153
 154     va_start(args, expectedFormat);
 155     vprintf(expectedFormat, args);
 156     va_end(args);
 157 }
 158
 159
 160 void tfp_format(void *, void (*) (void *, char), const char * expectedFormat, va_list va) {
 161     vprintf(expectedFormat, va);
 162 }
 163
 164 static const box_t boxes[] = { { 0, "DUMMYBOX", 0 } };
 165 const box_t *findBoxByPermanentId(uint8_t) { return &boxes[0]; }
 166 const box_t *findBoxByBoxId(boxId_e) { return &boxes[0]; }
 167
 168 int8_t unitTestDataArray[3];
 169
 170 void pgResetFn_unitTestData(int8_t *ptr) {
 171     ptr = &unitTestDataArray[0];
 172 }
 173
 174 uint32_t getBeeperOffMask(void) { return 0; }
 175 uint32_t getPreferredBeeperOffMask(void) { return 0; }
 176
 177 void beeper(beeperMode_e) {}
 178 void beeperSilence(void) {}
 179 void beeperConfirmationBeeps(uint8_t) {}
 180 void beeperWarningBeeps(uint8_t) {}
 181 void beeperUpdate(timeUs_t) {}
 182 uint32_t getArmingBeepTimeMicros(void) {return 0;}
 183 beeperMode_e beeperModeForTableIndex(int) {return BEEPER_SILENCE;}
 184 uint32_t beeperModeMaskForTableIndex(int idx) {UNUSED(idx); return 0;}
 185 const char *beeperNameForTableIndex(int) {return NULL;}
 186 int beeperTableEntryCount(void) {return 0;}
 187 bool isBeeperOn(void) {return false;}
 188 void beeperOffSetAll(uint8_t) {}
 189 void setBeeperOffMask(uint32_t) {}
 190 void setPreferredBeeperOffMask(uint32_t) {}
 191
 192 void beeperOffSet(uint32_t) {}
 193 void beeperOffClear(uint32_t) {}
 194 void beeperOffClearAll(void) {}
 195 bool parseColor(int, const char *) {return false; }
 196 void resetEEPROM(void) {}
 197 void bufWriterFlush(bufWriter_t *) {}
 198 void mixerResetDisarmedMotors(void) {}
 199 void gpsEnablePassthrough(struct serialPort_s *) {}
 200 bool parseLedStripConfig(int, const char *){return false; }
 201 const char rcChannelLetters[] = "AERT12345678abcdefgh";
 202
 203 void parseRcChannels(const char *, rxConfig_t *){}
 204 void mixerLoadMix(int, motorMixer_t *) {}
 205 bool setModeColor(ledModeIndex_e, int, int) { return false; }
 206 float convertExternalToMotor(uint16_t ){ return 1.0; }
 207 uint8_t getCurrentPidProfileIndex(void){ return 1; }
 208 uint8_t getCurrentControlRateProfileIndex(void){ return 1; }
 209 void changeControlRateProfile(uint8_t) {}
 210 void resetAllRxChannelRangeConfigurations(rxChannelRangeConfig_t *) {}
 211 void writeEEPROM() {}
 212 serialPortConfig_t *serialFindPortConfiguration(serialPortIdentifier_e) {return NULL; }
 213 baudRate_e lookupBaudRateIndex(uint32_t){return BAUD_9600; }
 214 serialPortUsage_t *findSerialPortUsageByIdentifier(serialPortIdentifier_e){ return NULL; }
 215 serialPort_t *openSerialPort(serialPortIdentifier_e, serialPortFunction_e, serialReceiveCallbackPtr, void *, uint32_t, portMode_e, portOptions_e) { return NULL; }
 216 void serialSetBaudRate(serialPort_t *, uint32_t) {}
 217 void serialSetMode(serialPort_t *, portMode_e) {}
 218 void serialPassthrough(serialPort_t *, serialPort_t *, serialConsumer *, serialConsumer *) {}
 219 uint32_t millis(void) { return 0; }
 220 uint8_t getBatteryCellCount(void) { return 1; }
 221 void servoMixerLoadMix(int) {}
 222 const char * getBatteryStateString(void){ return "_getBatteryStateString_"; }
 223
 224 uint32_t stackTotalSize(void) { return 0x4000; }
 225 uint32_t stackHighMem(void) { return 0x80000000; }
 226 uint16_t getEEPROMConfigSize(void) { return 1024; }
 227
 228 uint8_t __config_start = 0x00;
 229 uint8_t __config_end = 0x10;
 230 uint16_t averageSystemLoadPercent = 0;
 231
 232 timeDelta_t getTaskDeltaTime(cfTaskId_e){ return 0; }
 233 armingDisableFlags_e getArmingDisableFlags(void) { return ARMING_DISABLED_NO_GYRO; }
 234
 235 const char *armingDisableFlagNames[]= {
 236 "DUMMYDISABLEFLAGNAME"
 237 };
 238
 239 void getTaskInfo(cfTaskId_e, cfTaskInfo_t *) {}
 240 void getCheckFuncInfo(cfCheckFuncInfo_t *) {}
 241
 242 const char * const targetName = "UNITTEST";
 243 const char* const buildDate = "Jan 01 2017";
 244 const char * const buildTime = "00:00:00";
 245 const char * const shortGitRevision = "MASTER";
 246
 247 uint32_t serialRxBytesWaiting(const serialPort_t *) {return 0;}
 248 uint8_t serialRead(serialPort_t *){return 0;}
 249
 250 void bufWriterAppend(bufWriter_t *, uint8_t ch){ printf("%c", ch); }
 251 void serialWriteBufShim(void *, const uint8_t *, int) {}
 252 bufWriter_t *bufWriterInit(uint8_t *, int, bufWrite_t, void *) {return NULL;}
 253 void schedulerSetCalulateTaskStatistics(bool) {}
 254 void setArmingDisabled(armingDisableFlags_e) {}
 255
 256 void waitForSerialPortToFinishTransmitting(serialPort_t *) {}
 257 void stopPwmAllMotors(void) {}
 258 void systemResetToBootloader(void) {}
 259 void resetConfigs(void) {}
 260 void systemReset(void) {}
 261
 262 void changePidProfile(uint8_t) {}
 263 bool serialIsPortAvailable(serialPortIdentifier_e) { return false; }
 264 void generateLedConfig(ledConfig_t *, char *, size_t) {}
 265 bool isSerialTransmitBufferEmpty(const serialPort_t *) {return true; }
 266 void serialWrite(serialPort_t *, uint8_t ch) { printf("%c", ch);}
 267
 268 void serialSetCtrlLineStateCb(serialPort_t *, void (*)(void *, uint16_t ), void *) {}
 269 void serialSetCtrlLineStateDtrPin(serialPort_t *, ioTag_t ) {}
 270 void serialSetCtrlLineState(serialPort_t *, uint16_t ) {}
 271
 272 void serialSetBaudRateCb(serialPort_t *, void (*)(serialPort_t *context, uint32_t baud), serialPort_t *) {}
 273
 274 }