C or C++ preprocessor selecting code blocks - c++

Question

I'm trying to write a production test software for an embedded system where I could write a single test script (which ideally is just C++ code), where parts are executed on the host computer and part on the DUT (Device Under Test). Communication is through a serial port.
One important goal here is to reduce code size on the embedded side, without reducing readability of the test output. So my level 0 objective, you could say a warmup exercise, is to be able to write something like this:
//TestScript.cpp
START_TESTS()
...
const unsigned pot1res = testPotentiometer(pot1);
TEST_PRINT("Potentiometer 1 test result %u", pot1res);
const unsigned pot2res = testPotentiometer(pot2);
TEST_PRINT("Potentiometer 2 test result %u", pot2res);
...
END_TESTS()
which would compile through preprocessor trickery and selective compilation on the embedded side to
const unsigned pot1res = testPotentiometer(pot1);
write_uart(123); //Unique id, perhaps from __COUNTER__
write_uart(pot1res);
const unsigned pot2res = testPotentiometer(pot2);
write_uart(124); //Unique id, perhaps from __COUNTER__
write_uart(pot2res);
and on the host
std::array gTestStrings = {
... other strings ....
TestString{123, "Potentiometer 1 test result %u", unsigned_tag},
TestString{124, "Potentiometer 2 test result %u", unsigned_tag},
... more strings ....
};
The purpose of the latter is then of course that the host software simply listens to the UART for the unique id's, then looks up the needed parameters from gTestStrings, receives them, and prints out the message to its test log. Note that the strings have disappeared entirely from the embedded side.
The embedded side here is of course easy, just define the TEST_PRINT macro in the obvious way, and supporting varargs etc shouldn't be too difficult. However, it's not clear how define the host side, since the code in between the macros has to disappear entirely. I'm pretty sure I can deal with getting the unsigned_tags etc correctly with some templates etc.
Standard C++17 is appreciated, but GCC/Clang specifics are allowed if needed, the preprocessor will obviously play heavily into this etc. The syntax of the macros can of course also be adjusted where necessary.

Answer 1

On the basis of "use templates to do the same thing with different types" you could simply define a templated class or method which invoke different implementations according to whether in the embedded context or host context.
Pseudocode example:
#include <sstream>
#include <string>
class Mock
{
protected:
// TODO : output values array / map - by - testID
public:
unsigned readPot(int const testID)
{
// TODO : return value from the values array/map
}
};
class ActualDevice
{
public:
unsigned readPot(int const testID)
{
// TODO : write/read the device
}
};
//DEVICE_IMPL must implement a method with this signature:
//unsigned readPot(int const testID)
template<typename DEVICE_IMPL>
void runTests()
{
DEVICE_IMPL device;
std::string testOutput;
//TODO : substitute with for-loop to run all tests
int testID = 1;
{
unsigned output = device.readPot(testID);
std::stringstream accum;
accum << "Test " << testID << " output = " << (int)output << std::endl;
testOutput = accum.str();
// TODO : do something with testOutput
}
}
void testHost ()
{
runTests<Mock>();
}
void testDevice()
{
runTests<ActualDevice>();
}

Answer 2

#ifdef __linux__ // or whatever you have there
#define START_TESTS() std::array gTestStrings = {
#define END_TESTS() };
#define TEST(expr, str) TestString{__LINE__, str, unsigned_tag},
#else
#define START_TESTS() {
#define END_TESTS() }
#define TEST(expr, ...) do{ \
const auto _val = (expr); \
write_uart(__LINE__); \
write_uart(_val); \
} while(0)
#endif
int main() {
START_TESTS()
TEST(testPotentiometer(pot1), "Potentiometer 1 test result %u");
TEST(testPotentiometer(pot2), "Potentiometer 2 test result %u");
END_TESTS()
}
I do not particularly like that design - seems not flexible enough for me. But such code could serve as a template for you to write something better. I added the expression inside the TEST macro - that way it can be removed on the host side, and used on the device side.

Answer 3

Another option could be X-macros:
pot_tests.h
X(123, pot1, "Potentiometer 1 test result %u")
X(124, pot2, "Potentiometer 2 test result %u")
embedded.c
START_TESTS()
...
#define X(id, pot, text) \
do { \
const unsigned potres = testPotentiometer(pot); \
write_uart(id); \
write_uart(potres); \
TEST_PRINT(text, potres); \
} while(0);
#include "pot_tests.h"
#undef X
...
END_TESTS()
host.cpp
std::array gTestStrings = {
... other strings ....
#define X(id, pot, text) TestString{id, text, unsigned_tag},
#include "pot_tests.h"
#undef X
... more strings ....
};