int main() {
{
struct map map;
map_init(&map);
char key1[] = "This is a really long key.",
key2[] = "Another key.";
assertError("map_set (1)", map_set(&map, key1, sizeof key1, (void*)123));
assertEq("Key is now retrievable", map_get(&map, key1, sizeof key1), (void*)123);
assertError("map_set (2)", map_set(&map, key2, sizeof key2, (void*)456));
assertEq("New key is now retrievable", map_get(&map, key2, sizeof key2), (void*)456);
assertEq("Old key is still retrievable (1)", map_get(&map, key1, sizeof key1), (void*)123);
assertError("map_set existing", map_set(&map, key1, sizeof key1, (void*)789));
assertEq("Key has updated value", map_get(&map, key1, sizeof key1), (void*)789);
assertEq("Old key is still retrievable (2)", map_get(&map, key2, sizeof key2), (void*)456);
assertError("map_set small key (1)", map_set(&map, (void*)1, 0, (void*)10));
assertError("map_set small key (2)", map_set(&map, (void*)2, 0, (void*)20));
assertEq("Can retrieve short key (1)", map_get(&map, (void*)1, 0), (void*)10);
assertEq("Can retrieve short key (2)", map_get(&map, (void*)2, 0), (void*)20);
map_free(&map);
}
}
void ZeroMQSocketTests::testBasicSendReceive() {
const std::string endpoint("tcp://127.0.0.1:19992");
const std::string outgoingMessage("Hello, world!");
ZeroMQSocket::Message incomingMessage;
ZeroMQSocket sender(ZMQ_PUSH);
CPPUNIT_ASSERT( sender.setOption(ZMQ_IMMEDIATE, 1) );
ZeroMQSocket receiver(ZMQ_PULL);
// Send failure
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == receiver.send(outgoingMessage.data(), outgoingMessage.size()) );
assertError("ERROR: Cannot send on ZeroMQ socket: Operation not supported");
// Receive failure
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == incomingMessage.recv(sender) );
assertError("ERROR: Cannot receive on ZeroMQ socket: Operation not supported");
// Send timeout
CPPUNIT_ASSERT( ZeroMQSocket::Result::timeout == sender.send(outgoingMessage.data(),
outgoingMessage.size(),
ZMQ_DONTWAIT) ); // Flag
CPPUNIT_ASSERT( sender.setOption(ZMQ_SNDTIMEO, 100) ); // Option
CPPUNIT_ASSERT( sender.connect(endpoint) );
CPPUNIT_ASSERT( ZeroMQSocket::Result::timeout == sender.send(outgoingMessage.data(), outgoingMessage.size()) );
// Receive timeout
CPPUNIT_ASSERT( ZeroMQSocket::Result::timeout == incomingMessage.recv(receiver, ZMQ_DONTWAIT) ); // Flag
CPPUNIT_ASSERT( receiver.setOption(ZMQ_RCVTIMEO, 100) ); // Option
CPPUNIT_ASSERT( receiver.bind(endpoint) );
CPPUNIT_ASSERT( ZeroMQSocket::Result::timeout == incomingMessage.recv(receiver) );
// Success
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == sender.send(outgoingMessage.data(), outgoingMessage.size()) );
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == incomingMessage.recv(receiver) );
CPPUNIT_ASSERT_EQUAL( outgoingMessage, std::string(static_cast<const char *>(incomingMessage.getData()),
incomingMessage.getSize()) );
CPPUNIT_ASSERT( sender.disconnect(endpoint) );
CPPUNIT_ASSERT( receiver.unbind(endpoint) );
}
void ZeroMQSocketTests::testUnbindFailure() {
ZeroMQSocket s(ZMQ_PUB);
CPPUNIT_ASSERT( !s.unbind("pct://*:*") );
assertError("ERROR: Cannot unbind ZeroMQ socket: Protocol not supported");
}
void ZeroMQSocketTests::testDisconnectFailure() {
ZeroMQSocket s(ZMQ_SUB);
CPPUNIT_ASSERT( !s.disconnect("pct://*:*") );
assertError("ERROR: Cannot disconnect ZeroMQ socket: Protocol not supported");
}
void ZeroMQSocketTests::testSetOptionFailure() {
ZeroMQSocket s(ZMQ_PAIR);
CPPUNIT_ASSERT( !s.setOption(123456, 0) );
assertError("ERROR: Cannot set option on ZeroMQ socket: Invalid argument");
}
void ZeroMQSocketTests::testEventSendReceive() {
const std::string endpoint("tcp://127.0.0.1:19992");
const boost::endian::big_uint16_t eventCode = 512;
const MWTime eventTime = 1234567890;
const Datum eventData(Datum::list_value_type { Datum(true), Datum(2.5), Datum("foo") });
const auto outgoingEvent = boost::make_shared<Event>(eventCode, eventTime, eventData);
boost::shared_ptr<Event> incomingEvent;
ZeroMQSocket sender(ZMQ_PUSH);
CPPUNIT_ASSERT( sender.setOption(ZMQ_IMMEDIATE, 1) );
CPPUNIT_ASSERT( sender.setOption(ZMQ_SNDTIMEO, 100) );
ZeroMQSocket receiver(ZMQ_PULL);
CPPUNIT_ASSERT( receiver.setOption(ZMQ_RCVTIMEO, 100) );
// Send failure
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == receiver.send(outgoingEvent) );
assertError("ERROR: Cannot send on ZeroMQ socket: Operation not supported");
// Receive failure
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == sender.recv(incomingEvent) );
assertError("ERROR: Cannot receive on ZeroMQ socket: Operation not supported");
// Send timeout
CPPUNIT_ASSERT( sender.connect(endpoint) );
CPPUNIT_ASSERT( ZeroMQSocket::Result::timeout == sender.send(outgoingEvent) );
// Receive timeout
CPPUNIT_ASSERT( receiver.bind(endpoint) );
CPPUNIT_ASSERT( ZeroMQSocket::Result::timeout == receiver.recv(incomingEvent) );
// Negative event code
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == sender.send(boost::make_shared<Event>(-1, eventTime, eventData)) );
assertError("ERROR: Cannot send event: event code (-1) is out of range");
// Out-of-bounds event code
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == sender.send(boost::make_shared<Event>(int(std::numeric_limits<std::uint16_t>::max()) + 1,
eventTime,
eventData)) );
assertError("ERROR: Cannot send event: event code (65536) is out of range");
// Wrong header size
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == sender.send(&eventTime, sizeof(eventTime)) );
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == receiver.recv(incomingEvent) );
assertError("ERROR: Received invalid event: header has wrong size (expected 2 bytes, got 8 bytes)");
// No body
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == sender.send(&eventCode, sizeof(eventCode)) );
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == receiver.recv(incomingEvent) );
assertError("ERROR: Received invalid event: body is missing");
// Invalid body
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == sender.send(&eventCode, sizeof(eventCode), ZMQ_SNDMORE) );
{
std::ostringstream buffer;
msgpack::pack(buffer, eventTime);
msgpack::pack(buffer, eventData);
auto data = buffer.str();
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == sender.send(data.data(), data.size() - 1) ); // Not enough data
}
CPPUNIT_ASSERT( ZeroMQSocket::Result::error == receiver.recv(incomingEvent) );
assertError("ERROR: Received invalid event: body is invalid or corrupt");
// Success
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == sender.send(outgoingEvent) );
incomingEvent.reset();
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == receiver.recv(incomingEvent) );
CPPUNIT_ASSERT_EQUAL( int(eventCode), incomingEvent->getEventCode() );
CPPUNIT_ASSERT_EQUAL( eventTime, incomingEvent->getTime() );
CPPUNIT_ASSERT( eventData == incomingEvent->getData() );
// Extra data
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == sender.send(&eventCode, sizeof(eventCode), ZMQ_SNDMORE) );
{
std::ostringstream buffer;
msgpack::pack(buffer, eventTime);
msgpack::pack(buffer, eventData);
msgpack::pack(buffer, 512);
auto data = buffer.str();
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == sender.send(data.data(), data.size()) );
}
incomingEvent.reset();
CPPUNIT_ASSERT( ZeroMQSocket::Result::ok == receiver.recv(incomingEvent) );
assertMessage(M_WARNING_MESSAGE, "WARNING: Received event body contains 3 bytes of extra data that will be ignored");
CPPUNIT_ASSERT_EQUAL( int(eventCode), incomingEvent->getEventCode() );
CPPUNIT_ASSERT_EQUAL( eventTime, incomingEvent->getTime() );
CPPUNIT_ASSERT( eventData == incomingEvent->getData() );
CPPUNIT_ASSERT( sender.disconnect(endpoint) );
CPPUNIT_ASSERT( receiver.unbind(endpoint) );
}
void EEPROMMemoryAdapter::write(uint32_t address, uint8_t* data, size_t length) {
if (assertAddress(address, length))
assertError(memory.writeBytes(address, data, length));
}
void EEPROMMemoryAdapter::read(uint32_t address, uint8_t* data, size_t length) {
if (assertAddress(address, length))
assertError(memory.readBytes(address, data, length));
else
memset(data, 0, length); // Daten mit 0 befüllen, damit der Leser bei Fehlern keine zufällige Werte bekommt
}
void EEPROMMemoryAdapter::writeByte(uint32_t address, uint8_t val) {
if (assertAddress(address, sizeof(uint8_t)))
assertError(memory.writeByte(address, val));
}
