Merge branch 'mueller_framework'

container/FixedArrayList.h

@@ -12,14 +12,26 @@ class FixedArrayList: public ArrayList<T, count_t> {
 private:
 	T data[MAX_SIZE];
 public:
+	/**
+	 * (Robin) Maybe we should also implement move assignment and move ctor.
+	 * Or at least delete them.
+	 */
 	FixedArrayList() :
 			ArrayList<T, count_t>(data, MAX_SIZE) {
 	}
 
-	//We could create a constructor to initialize the fixed array list with data and the known size field
-	//so it can be used for serialization too (with SerialFixedArrrayListAdapter)
-	//is this feasible?
-	FixedArrayList(T * data_, count_t count, bool swapArrayListEndianess = false):
+	// (Robin): We could create a constructor to initialize the fixed array list with data and the known size field
+	// so it can be used for serialization too (with SerialFixedArrrayListAdapter)
+	// is this feasible?
+	/**
+	 * Initialize a fixed array list with data and number of data fields.
+	 * Endianness of entries can be swapped optionally.
+	 * @param data_
+	 * @param count
+	 * @param swapArrayListEndianess
+	 */
+	FixedArrayList(T * data_, count_t count,
+			bool swapArrayListEndianess = false):
 		ArrayList<T, count_t>(data, MAX_SIZE) {
 		memcpy(this->data, data_, count * sizeof(T));
 		this->size = count;

container/FixedMap.h

@@ -201,7 +201,7 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
 				buffer, size, bigEndian);

container/IsDerivedFrom.h

@@ -1,6 +1,13 @@
 #ifndef ISDERIVEDFROM_H_
 #define ISDERIVEDFROM_H_
 
+/**
+ * These template type checks are based on SFINAE
+ * (https://en.cppreference.com/w/cpp/language/sfinae)
+ *
+ * @tparam D Derived Type
+ * @tparam B Base Type
+ */
 template<typename D, typename B>
 class IsDerivedFrom {
 	class No {
@@ -9,7 +16,9 @@ class IsDerivedFrom {
 		No no[3];
 	};
 
+	// This will be chosen if B is the base type
 	static Yes Test(B*); // declared, but not defined
+	// This will be chosen for anything else
 	static No Test(... ); // declared, but not defined
 
 public:

datapool/DataPoolParameterWrapper.cpp

@@ -80,7 +80,7 @@ size_t DataPoolParameterWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 

datapool/DataPoolParameterWrapper.h

@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,

datapool/DataSet.cpp

@@ -136,7 +136,7 @@ void DataSet::setValid(uint8_t valid) {
 	}
 }
 
-ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (uint16_t count = 0; count < fill_count; count++) {

datapool/DataSet.h

@@ -126,7 +126,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 private:

datapool/PIDReader.h

@@ -136,7 +136,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}

datapool/PoolRawAccess.cpp

@@ -197,11 +197,11 @@ size_t PoolRawAccess::getSerializedSize() const {
 	return typeSize;
 }
 
-ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
-	*size -= typeSize;
-	if (*size >= 0) {
-
+	// TODO: Needs to be tested!!!
+	if (*size >= typeSize) {
+		*size -= typeSize;
 		if (bigEndian) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
@@ -212,12 +212,14 @@ ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, ssize_t* size,
 #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
 			memcpy(value, *buffer, typeSize);
 #endif
-		} else {
+		}
+		else {
 			memcpy(value, *buffer, typeSize);
 		}
 		*buffer += typeSize;
 		return HasReturnvaluesIF::RETURN_OK;
-	} else {
+	}
+	else {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 }

datapool/PoolRawAccess.h

@@ -127,7 +127,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 protected:

datapool/PoolRawAccessHelper.cpp

@@ -25,7 +25,7 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
 		const size_t max_size, bool bigEndian) {
 	SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
 	ReturnValue_t result;
-	ssize_t remainingParametersSize = numberOfParameters * 4;
+	size_t remainingParametersSize = numberOfParameters * 4;
 	for(uint8_t count=0; count < numberOfParameters; count++) {
 		result = serializeCurrentPoolEntryIntoBuffer(serializationArgs,
 				&remainingParametersSize, false);
@@ -44,7 +44,7 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 		size_t * size, const size_t max_size, bool bigEndian) {
 	ReturnValue_t result;
 	SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
-	ssize_t remainingParametersSize = numberOfParameters * 4;
+	size_t remainingParametersSize = numberOfParameters * 4;
 	uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
 	uint8_t validityMask[validityMaskSize];
 	memset(validityMask,0, validityMaskSize);
@@ -67,49 +67,60 @@ ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-		ssize_t * remainingParameters, bool withValidMask, uint8_t * validityMask) {
+ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
+		SerializationArgs argStruct, size_t * remainingParameters,
+		bool withValidMask, uint8_t * validityMask) {
 	uint32_t currentPoolId;
 	// Deserialize current pool ID from pool ID buffer
 	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
 			&poolIdBuffer,remainingParameters,true);
 	if(result != RETURN_OK) {
-		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing pool IDs" << std::dec << std::endl;
+		debug << std::hex << "Pool Raw Access Helper: Error deSeralizing "
+				"pool IDs" << std::dec << std::endl;
 		return result;
 	}
-	result = handlePoolEntrySerialization(currentPoolId, argStruct, withValidMask, validityMask);
+	result = handlePoolEntrySerialization(currentPoolId, argStruct,
+			withValidMask, validityMask);
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t currentPoolId,SerializationArgs argStruct,
-		bool withValidMask, uint8_t * validityMask) {
+ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
+		uint32_t currentPoolId,SerializationArgs argStruct, bool withValidMask,
+		uint8_t * validityMask) {
 	ReturnValue_t result = RETURN_FAILED;
 	uint8_t arrayPosition = 0;
 	uint8_t counter = 0;
 	bool poolEntrySerialized = false;
-	//debug << "Pool Raw Access Helper: Handling Pool ID: " << std::hex <<  currentPoolId << std::endl;
+	//debug << "Pool Raw Access Helper: Handling Pool ID: "
+	//      << std::hex <<  currentPoolId << std::endl;
 	while(not poolEntrySerialized) {
 
 		if(counter > DataSet::DATA_SET_MAX_SIZE) {
-			error << "Pool Raw Access Helper: Config error, max. number of possible data set variables exceeded" << std::endl;
+			error << "Pool Raw Access Helper: Config error, "
+					 "max. number of possible data set variables exceeded"
+				  << std::endl;
 			return result;
 		}
 		counter ++;
 
 		DataSet currentDataSet = DataSet();
 		//debug << "Current array position: " << (int)arrayPosition << std::endl;
-		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,&currentDataSet,PoolVariableIF::VAR_READ);
+		PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,
+				&currentDataSet,PoolVariableIF::VAR_READ);
 
 		result = currentDataSet.read();
 		if (result != RETURN_OK) {
-			debug << std::hex << "Pool Raw Access Helper: Error reading raw dataset with returncode 0x"
+			debug << std::hex << "Pool Raw Access Helper: Error reading raw "
+					"dataset with returncode 0x"
 				  << result << std::dec << std::endl;
 			return result;
 		}
 
-		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized, &arrayPosition);
+		result = checkRemainingSize(&currentPoolRawAccess, &poolEntrySerialized,
+				&arrayPosition);
 		if(result != RETURN_OK) {
-			error << "Pool Raw Access Helper: Configuration Error at pool ID " << std::hex << currentPoolId
+			error << "Pool Raw Access Helper: Configuration Error at pool ID "
+				  << std::hex << currentPoolId
 				  << ". Size till end smaller than 0" << std::dec << std::endl;
 			return result;
 		}
@@ -125,8 +136,9 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 		result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
 				argStruct.max_size, argStruct.bigEndian);
 		if (result != RETURN_OK) {
-			debug << "Pool Raw Access Helper: Error serializing pool data with ID 0x" << std::hex <<
-					currentPoolId << " into send buffer with return code " << result << std::dec << std::endl;
+			debug << "Pool Raw Access Helper: Error serializing pool data with "
+					 "ID 0x" << std::hex << currentPoolId << " into send buffer "
+					 "with return code " << result << std::dec << std::endl;
 			return result;
 		}
 
@@ -134,9 +146,10 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(uint32_t current
 	return result;
 }
 
-ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess * currentPoolRawAccess,
-		bool * isSerialized, uint8_t * arrayPosition) {
-	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() - currentPoolRawAccess->getSizeOfType();
+ReturnValue_t PoolRawAccessHelper::checkRemainingSize(PoolRawAccess*
+		currentPoolRawAccess, bool * isSerialized, uint8_t * arrayPosition) {
+	int8_t remainingSize = currentPoolRawAccess->getSizeTillEnd() -
+			currentPoolRawAccess->getSizeOfType();
 	if(remainingSize == 0) {
 		*isSerialized = true;
 	}
@@ -158,7 +171,8 @@ void PoolRawAccessHelper::handleMaskModification(uint8_t * validityMask) {
 	}
 }
 
-uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position, bool value) {
+uint8_t PoolRawAccessHelper::bitSetter(uint8_t byte, uint8_t position,
+		bool value) {
 	if(position < 1 or position > 8) {
 		debug << "Pool Raw Access: Bit setting invalid position" << std::endl;
 		return byte;

datapool/PoolRawAccessHelper.h

@@ -69,7 +69,7 @@ private:
 	struct SerializationArgs {
 		uint8_t ** buffer;
 		size_t * size;
-		const uint32_t max_size;
+		const size_t max_size;
 		bool bigEndian;
 	};
 	/**
@@ -80,13 +80,15 @@ private:
 	 * @param hkDataSize
 	 * @param max_size
 	 * @param bigEndian
-	 * @param withValidMask Can be set optionally to set a provided validity mask
-	 * @param validityMask Can be supplied and will be set if @c withValidMask is set to true
+	 * @param withValidMask Can be set optionally to set a
+	 *        provided validity mask
+	 * @param validityMask Can be supplied and will be set if
+	 *  	  @c withValidMask is set to true
 	 * @return
 	 */
-	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(SerializationArgs argStruct,
-				ssize_t * remainingParameters, bool withValidMask = false,
-				uint8_t * validityMask = nullptr);
+	ReturnValue_t serializeCurrentPoolEntryIntoBuffer(
+			SerializationArgs argStruct, size_t * remainingParameters,
+			bool withValidMask = false, uint8_t * validityMask = nullptr);
 
 	ReturnValue_t handlePoolEntrySerialization(uint32_t currentPoolId,
 			SerializationArgs argStruct, bool withValidMask = false,

datapool/PoolVariable.h

@@ -203,7 +203,7 @@ public:
 		return SerializeAdapter<T>::getSerializedSize(&value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
 	}

datapool/PoolVector.h

@@ -215,7 +215,7 @@ public:
 		return vector_size * SerializeAdapter<T>::getSerializedSize(value);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		uint16_t i;
 		ReturnValue_t result;

devicehandlers/CookieIF.h

@@ -13,8 +13,9 @@ typedef uint32_t address_t;
  * 			single interface (like RMAP or I2C)
  * @details
  * To use this class, implement a communication specific child cookie which
- * inherits Cookie. Cookie instances are created in config/ Factory.cpp by calling
- * CookieIF* childCookie = new ChildCookie(...).
+ * inherits Cookie. Cookie instances are created in config/Factory.cpp by
+ * calling @code{.cpp} CookieIF* childCookie = new ChildCookie(...)
+ * @endcode .
  *
  * This cookie is then passed to the child device handlers, which stores the
  * pointer and passes it to the communication interface functions.

devicehandlers/DeviceCommunicationIF.h

@@ -60,9 +60,9 @@ public:
 	 * this can be performed in this function, which is called on device handler
 	 * initialization.
 	 * @param cookie
-	 * @return -@c RETURN_OK if initialization was successfull
-	 * 		   - Everything else triggers failure event with
-	 * 		   returnvalue as parameter 1
+	 * @return
+	 *  - @c RETURN_OK if initialization was successfull
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t initializeInterface(CookieIF * cookie) = 0;
 
@@ -73,9 +73,9 @@ public:
 	 * @param cookie
 	 * @param data
 	 * @param len
-	 * @return -@c RETURN_OK for successfull send
-	 *         - Everything else triggers failure event with
-	 *         returnvalue as parameter 1
+	 * @return
+	 *  - @c RETURN_OK for successfull send
+	 *  - Everything else triggers failure event with returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t * sendData,
 			size_t sendLen) = 0;
@@ -84,9 +84,9 @@ public:
 	 * Called by DHB in the GET_WRITE doGetWrite().
 	 * Get send confirmation that the data in sendMessage() was sent successfully.
 	 * @param cookie
-	 * @return -@c RETURN_OK if data was sent successfull
+	 * @return - @c RETURN_OK if data was sent successfull
 	 * 		   - Everything else triggers falure event with
-	 * 		   returnvalue as parameter 1
+	 * 		     returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 
@@ -99,9 +99,9 @@ public:
 	 *
 	 * @param cookie
 	 * @param requestLen Size of data to read
-	 * @return -@c RETURN_OK to confirm the request for data has been sent.
+	 * @return - @c RETURN_OK to confirm the request for data has been sent.
 	 *         - Everything else triggers failure event with
-	 *         returnvalue as parameter 1
+	 *           returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) = 0;
 
@@ -113,8 +113,8 @@ public:
 	 * @param buffer [out] Set reply here (by using *buffer = ...)
 	 * @param size [out] size pointer to set (by using *size = ...).
 	 * 	           Set to 0 if no reply was received
-	 * @return -@c RETURN_OK for successfull receive
-	 * 		   -@c NO_REPLY_RECEIVED if not reply was received. Setting size to
+	 * @return - @c RETURN_OK for successfull receive
+	 * 		   - @c NO_REPLY_RECEIVED if not reply was received. Setting size to
 	 * 		   	   0 has the same effect
 	 *         - Everything else triggers failure event with
 	 *           returnvalue as parameter 1

devicehandlers/DeviceHandlerBase.cpp

@@ -114,7 +114,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
 	AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
 			AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
-	if (rawReceiver == NULL) {
+	if (rawReceiver == nullptr) {
 		return RETURN_FAILED;
 	}
 

devicehandlers/DeviceTmReportingWrapper.cpp

@@ -31,7 +31,7 @@ size_t DeviceTmReportingWrapper::getSerializedSize() const {
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
 			buffer, size, bigEndian);
 	if (result != HasReturnvaluesIF::RETURN_OK) {

devicehandlers/DeviceTmReportingWrapper.h

@@ -16,7 +16,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 private:
 	object_id_t objectId;

events/eventmatching/EventRangeMatcherBase.h

@@ -18,7 +18,7 @@ public:
 	size_t getSerializedSize() const {
 		return rangeMatcher.getSerializedSize();
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return rangeMatcher.deSerialize(buffer, size, bigEndian);
 	}

framework.mk

@@ -54,3 +54,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
+CXXSRC += $(wildcard $(FRAMEWORK_PATH)/test/*.cpp)

globalfunctions/Type.cpp

@@ -85,7 +85,7 @@ size_t Type::getSerializedSize() const {
 	return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
 }
 
-ReturnValue_t Type::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
 		bool bigEndian) {
 	uint8_t ptc;
 	uint8_t pfc;

globalfunctions/Type.h

@@ -44,7 +44,7 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 private:

globalfunctions/matching/MatchTree.h

@@ -115,7 +115,7 @@ public:
 		return size;
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 		return HasReturnvaluesIF::RETURN_OK;
 	}

globalfunctions/matching/RangeMatcher.h

@@ -29,32 +29,38 @@ public:
 
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const {
-		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound, buffer, size, max_size, bigEndian);
+		ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound,
+				buffer, size, max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size, max_size, bigEndian);
+		result = SerializeAdapter<T>::serialize(&upperBound, buffer, size,
+				max_size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::serialize(&inverted, buffer, size, max_size, bigEndian);
+		return SerializeAdapter<bool>::serialize(&inverted, buffer, size,
+				max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
 		return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound, buffer, size, bigEndian);
+		ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound,
+				buffer, size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer, size, bigEndian);
+		result = SerializeAdapter<T>::deSerialize(&upperBound, buffer,
+				size, bigEndian);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		return SerializeAdapter<bool>::deSerialize(&inverted, buffer, size, bigEndian);
+		return SerializeAdapter<bool>::deSerialize(&inverted, buffer,
+				size, bigEndian);
 	}
 protected:
 	bool doMatch(T input) {

osal/FreeRTOS/BinarySemaphore.cpp

@@ -138,10 +138,8 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 	BaseType_t returncode = xSemaphoreGiveFromISR(semaphore, higherPriorityTaskWoken);
 	if (returncode == pdPASS) {
 		if(*higherPriorityTaskWoken == pdPASS) {
-			// Request context switch
-		    // TODO: I don't know if this will ever happen but if it does,
-		    // I want to to know in case this causes issues. If it doesn't
-		    // we should remove this.
+			// Request context switch because unblocking the semaphore
+		    // caused a high priority task unblock.
 			TaskManagement::requestContextSwitch(CallContext::isr);
 		}
 		return HasReturnvaluesIF::RETURN_OK;

osal/FreeRTOS/BinarySemaphore.h

@@ -35,24 +35,20 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
 	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
-	/**
-	 * Create a binary semaphore
-	 */
 	BinarySemaphore();
 
 	/**
-	 * Copy ctor
-	 * @param
+	 * @brief Copy ctor
 	 */
 	BinarySemaphore(const BinarySemaphore&);
 
 	/**
-	 * Copy assignment
+	 * @brief Copy assignment
 	 */
 	BinarySemaphore& operator=(const BinarySemaphore&);
 
 	/**
-	 * Move constructor
+	 * @brief Move constructor
 	 */
 	BinarySemaphore (BinarySemaphore &&);
 
@@ -81,16 +77,16 @@ public:
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
 	 * @param timeoutTicks
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
 	        BinarySemaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t giveBinarySemaphore();
 
@@ -108,8 +104,8 @@ public:
 	 /**
 	 * Wrapper function to give back semaphore from handle
 	 * @param semaphore
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t giveBinarySemaphore(SemaphoreHandle_t semaphore);
 
@@ -118,8 +114,8 @@ public:
 	 * @param semaphore
 	 * @param higherPriorityTaskWoken This will be set to pdPASS if a task with a higher priority
 	 *        was unblocked
-	 * @return -@c RETURN_OK on success
-	 *         -@c RETURN_FAILED on failure
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED on failure
 	 */
 	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);

osal/linux/FixedTimeslotTask.cpp

@@ -9,7 +9,9 @@
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = PTHREAD_STACK_MIN;
 
-FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_):PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
+FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_,
+		size_t stackSize_, uint32_t periodMs_):
+		PosixThread(name_,priority_,stackSize_),pst(periodMs_),started(false) {
 }
 
 FixedTimeslotTask::~FixedTimeslotTask() {

osal/linux/PeriodicPosixTask.h

@@ -9,7 +9,8 @@
 
 class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF {
 public:
-	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_, void(*deadlineMissedFunc_)());
+	PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_,
+			uint32_t period_, void(*deadlineMissedFunc_)());
 	virtual ~PeriodicPosixTask();
 	/**
 	 * @brief	The method to start the task.

parameters/ParameterWrapper.cpp

@@ -112,7 +112,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 
 	//treat from as a continuous Stream as we copy all of it
 	const uint8_t *fromAsStream = (const uint8_t *) from;
-	ssize_t streamSize = fromRows * fromColumns * sizeof(T);
+	size_t streamSize = fromRows * fromColumns * sizeof(T);
 
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
@@ -137,12 +137,12 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	return deSerialize(buffer, size, bigEndian, 0);
 }
 
 ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
+		size_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
 	ParameterWrapper streamDescription;
 
 	ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@@ -153,8 +153,10 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
 	return copyFrom(&streamDescription, startWritingAtIndex);
 }
 
-ReturnValue_t ParameterWrapper::set(const uint8_t* stream, ssize_t streamSize,
-		const uint8_t **remainingStream, ssize_t *remainingSize) {
+ReturnValue_t ParameterWrapper::set(const uint8_t* stream, size_t streamSize,
+		const uint8_t **remainingStream, size_t *remainingSize) {
+	// TODO: Replaced ssize_t for remainingSize and streamSize
+	// is the logic here correct?
 	ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
 			&streamSize, true);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -172,22 +174,22 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, ssize_t streamSize,
 		return result;
 	}
 
-	int32_t dataSize = type.getSize() * rows * columns;
+	size_t dataSize = type.getSize() * rows * columns;
 
 	if (streamSize < dataSize) {
 		return SerializeIF::STREAM_TOO_SHORT;
 	}
 
-	data = NULL;
+	data = nullptr;
 	readonlyData = stream;
 	pointsToStream = true;
 
 	stream += dataSize;
-	if (remainingStream != NULL) {
+	if (remainingStream !=  nullptr) {
 		*remainingStream = stream;
 	}
 	streamSize -= dataSize;
-	if (remainingSize != NULL) {
+	if (remainingSize != nullptr) {
 		*remainingSize = streamSize;
 	}
 

parameters/ParameterWrapper.h

@@ -30,10 +30,10 @@ public:
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian, uint16_t startWritingAtIndex = 0);
 
 	template<typename T>
@@ -111,8 +111,8 @@ public:
 	void setMatrix(const T& member) {
 		this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
 	}
-	ReturnValue_t set(const uint8_t *stream, ssize_t streamSize,
-			const uint8_t **remainingStream = NULL, ssize_t *remainingSize =
+	ReturnValue_t set(const uint8_t *stream, size_t streamSize,
+			const uint8_t **remainingStream = NULL, size_t *remainingSize =
 					NULL);
 
 	ReturnValue_t copyFrom(const ParameterWrapper *from,

power/Fuse.cpp

@@ -108,7 +108,7 @@ uint32_t Fuse::getSerializedSize() const {
 	return size;
 }
 
-ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
 bool bigEndian) {
 	ReturnValue_t result = RETURN_FAILED;
 	for (DeviceList::iterator iter = devices.begin(); iter != devices.end();

power/Fuse.h

@@ -52,7 +52,7 @@ public:
 	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
 			const size_t max_size, bool bigEndian) const;
 	uint32_t getSerializedSize() const;
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 				bool bigEndian);
 	void setAllMonitorsToUnchecked();
 	ReturnValue_t performOperation(uint8_t opCode);

power/PowerComponent.cpp

@@ -56,7 +56,7 @@ float PowerComponent::getMax() {
 	return max;
 }
 
-ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, ssize_t* size,
+ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
 	ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
 			size, bigEndian);

power/PowerComponent.h

@@ -24,7 +24,7 @@ public:
 
 	size_t getSerializedSize() const;
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian);
 
 	ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,

serialize/EndianSwapper.h

@@ -11,10 +11,14 @@
  */
 class EndianSwapper {
 private:
-	EndianSwapper() {
-	}
-	;
+	EndianSwapper() {};
 public:
+	/**
+	 * Swap the endianness of a variable with arbitrary type
+	 * @tparam T Type of variable
+	 * @param in variable
+	 * @return Variable with swapped endianness
+	 */
 	template<typename T>
 	static T swap(T in) {
 #ifndef BYTE_ORDER_SYSTEM
@@ -33,7 +37,14 @@ public:
 #error Unknown Byte Order
 #endif
 	}
-	static void swap(uint8_t* out, const uint8_t* in, uint32_t size) {
+
+	/**
+	 * Swap the endianness of a buffer.
+	 * @param out
+	 * @param in
+	 * @param size
+	 */
+	static void swap(uint8_t* out, const uint8_t* in, size_t size) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
@@ -49,21 +60,23 @@ public:
 
 	/**
 	 * Swap endianness of buffer entries
-	 * Template argument specifies buffer type
+	 * Template argument specifies buffer type. The number of entries
+	 * (not the buffer size!) must be supplied
 	 * @param out
 	 * @param in
-	 * @param size
+	 * @param size Number of buffer entries (not size of buffer in bytes!)
 	 */
 	template<typename T>
-	static void swap(T * out, const T * in, uint32_t size) {
+	static void swap(T * out, const T * in, uint32_t entries) {
 #ifndef BYTE_ORDER_SYSTEM
 #error BYTE_ORDER_SYSTEM not defined
 #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
 		const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
 		uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
-		for (uint8_t count = 0; count < size; count++) {
+		for (uint8_t count = 0; count < entries; count++) {
 			for(uint8_t i = 0; i < sizeof(T);i++) {
-				out_buffer[sizeof(T)* (count + 1) - i - 1] = in_buffer[count * sizeof(T) + i];
+				out_buffer[sizeof(T)* (count + 1) - i - 1] =
+						in_buffer[count * sizeof(T) + i];
 			}
 		}
 		return;

serialize/SerialArrayListAdapter.h

@@ -13,7 +13,7 @@
 
 /**
  * Also serializes length field !
- * \ingroup serialize
+ * @ingroup serialize
  */
 template<typename T, typename count_t = uint8_t>
 class SerialArrayListAdapter : public SerializeIF {
@@ -22,7 +22,7 @@ public:
 	}
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			const size_t max_size, bool bigEndian) const  override {
 		return serialize(adaptee, buffer, size, max_size, bigEndian);
 	}
 
@@ -41,7 +41,7 @@ public:
 		return result;
 	}
 
-	virtual size_t getSerializedSize() const {
+	virtual size_t getSerializedSize() const override {
 		return getSerializedSize(adaptee);
 	}
 
@@ -56,16 +56,19 @@ public:
 		return printSize;
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override {
 		return deSerialize(adaptee, buffer, size, bigEndian);
 	}
 
 	static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
-			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, bool bigEndian) {
 		count_t tempSize = 0;
 		ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
 				buffer, size, bigEndian);
+		if(result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
 		if (tempSize > list->maxSize()) {
 			return SerializeIF::TOO_MANY_ELEMENTS;
 		}

serialize/SerialBufferAdapter.cpp

@@ -12,8 +12,8 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(const void* buffer,
 }
 
 template<typename count_t>
-SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer, count_t bufferLength,
-		bool serializeLength) :
+SerialBufferAdapter<count_t>::SerialBufferAdapter(void* buffer,
+		count_t bufferLength, bool serializeLength) :
 		serializeLength(serializeLength), bufferLength(bufferLength) {
 	uint8_t * member_buffer = static_cast<uint8_t *>(buffer);
 	m_buffer = member_buffer;
@@ -26,8 +26,8 @@ SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
 }
 
 template<typename count_t>
-ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
-		const size_t max_size, bool bigEndian) const {
+ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer,
+		size_t* size, const size_t max_size, bool bigEndian) const {
 	uint32_t serializedLength = bufferLength;
 	if (serializeLength) {
 		serializedLength += AutoSerializeAdapter::getSerializedSize(
@@ -61,36 +61,38 @@ size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
 		return bufferLength;
 	}
 }
+
 template<typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
-		ssize_t* size, bool bigEndian) {
+		size_t* size, bool bigEndian) {
 	//TODO Ignores Endian flag!
-	if (buffer != NULL) {
-		if(serializeLength){
-			// Suggestion (would require removing rest of the block inside this if clause !):
-			//ReturnValue_t result = AutoSerializeAdapter::deSerialize(&bufferLength,buffer,size,bigEndian);
-			//if (result != HasReturnvaluesIF::RETURN_OK) {
-			//	return result;
-			//}
+	// (Robin) the one of the buffer? wouldn't that be an issue for serialize
+	// as well? SerialFixedArrayListAdapter implements swapping of buffer
+	// fields (if buffer type is not uint8_t)
+	if (buffer != nullptr) {
+		if(serializeLength) {
 			count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
 					&bufferLength);
-			if((*size - bufferLength - serializedSize) >= 0){
+			if(bufferLength + serializedSize >= *size) {
 				*buffer +=  serializedSize;
 				*size -= serializedSize;
-			}else{
+			}
+			else {
 				return STREAM_TOO_SHORT;
 			}
 		}
 		//No Else If, go on with buffer
-		if (*size - bufferLength >= 0) {
+		if (bufferLength >= *size) {
 			*size -= bufferLength;
 			memcpy(m_buffer, *buffer, bufferLength);
 			(*buffer) += bufferLength;
 			return HasReturnvaluesIF::RETURN_OK;
-		} else {
+		}
+		else {
 			return STREAM_TOO_SHORT;
 		}
-	} else {
+	}
+	else {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 }
@@ -98,7 +100,8 @@ ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
 template<typename count_t>
 uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 	if(m_buffer == nullptr) {
-		error << "Wrong access function for stored type ! Use getConstBuffer()" << std::endl;
+		error << "Wrong access function for stored type !"
+				 " Use getConstBuffer()" << std::endl;
 		return nullptr;
 	}
 	return m_buffer;
@@ -107,14 +110,16 @@ uint8_t * SerialBufferAdapter<count_t>::getBuffer() {
 template<typename count_t>
 const uint8_t * SerialBufferAdapter<count_t>::getConstBuffer() {
 	if(constBuffer == nullptr) {
-		error << "Wrong access function for stored type ! Use getBuffer()" << std::endl;
+		error << "Wrong access function for stored type !"
+				 " Use getBuffer()" << std::endl;
 		return nullptr;
 	}
 	return constBuffer;
 }
 
 template<typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(void * buffer, count_t buffer_length) {
+void SerialBufferAdapter<count_t>::setBuffer(void * buffer,
+		count_t buffer_length) {
 	m_buffer = static_cast<uint8_t *>(buffer);
 	bufferLength = buffer_length;
 }

serialize/SerialBufferAdapter.h

@@ -8,11 +8,13 @@
  * This adapter provides an interface for SerializeIF to serialize or deserialize
  * buffers with no length header but a known size.
  *
- * Additionally, the buffer length can be serialized too and will be put in front of the serialized buffer.
+ * Additionally, the buffer length can be serialized too and will be put in
+ * front of the serialized buffer.
  *
  * Can be used with SerialLinkedListAdapter by declaring a SerializeElement with
- * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>> serialBufferElement.
- * Right now, the SerialBufferAdapter must always be initialized with the buffer and size !
+ * SerialElement<SerialBufferAdapter<bufferLengthType(will be uint8_t mostly)>>.
+ * Right now, the SerialBufferAdapter must always
+ * be initialized with the buffer and size !
  *
  * \ingroup serialize
  */
@@ -27,26 +29,40 @@ public:
 	 * @param bufferLength
 	 * @param serializeLength
 	 */
-	SerialBufferAdapter(const void* buffer, count_t bufferLength, bool serializeLength = false);
+	SerialBufferAdapter(const void* buffer, count_t bufferLength,
+			bool serializeLength = false);
 
 	/**
-	 * Constructor for non-constant uint8_t buffer. Length field can be serialized optionally.
+	 * Constructor for non-constant uint8_t buffer.
+	 * Length field can be serialized optionally.
 	 * Type of length can be supplied as template type.
 	 * @param buffer
 	 * @param bufferLength
-	 * @param serializeLength
+	 * @param serializeLength Length field will be serialized with size count_t
 	 */
 	SerialBufferAdapter(void* buffer, count_t bufferLength, bool serializeLength = false);
 
 	virtual ~SerialBufferAdapter();
 
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const;
+			const size_t max_size, bool bigEndian) const override;
 
 	virtual size_t getSerializedSize() const;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
-			bool bigEndian);
+	/**
+	 * @brief This function deserializes a buffer into the member buffer.
+	 * @details
+	 * If a length field is present, it is ignored, as the size should have
+	 * been set in the constructor. If the size is not known beforehand,
+	 * consider using SerialFixedArrayListAdapter instead.
+	 * @param buffer [out] Resulting buffer
+	 * @param size remaining size to deserialize, should be larger than buffer
+	 *        + size field size
+	 * @param bigEndian
+	 * @return
+	 */
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override;
 
 	uint8_t * getBuffer();
 	const uint8_t * getConstBuffer();
@@ -58,6 +74,4 @@ private:
 	count_t bufferLength = 0;
 };
 
-
-
 #endif /* SERIALBUFFERADAPTER_H_ */

serialize/SerialFixedArrayListAdapter.h

@@ -5,49 +5,62 @@
 #include <framework/serialize/SerialArrayListAdapter.h>
 
 /**
- * @brief This adapter provides an interface for SerializeIF to serialize and deserialize
- *        buffers with a header containing the buffer length.
+ * @brief 	This adapter provides an interface for SerializeIF to serialize and
+ * 			deserialize buffers with a header containing the buffer length.
  * @details
- *
  * Can be used by SerialLinkedListAdapter by declaring
  * as a linked element with SerializeElement<SerialFixedArrayListAdapter<...>>.
- * The sequence of objects is defined in the constructor by using the setStart and setNext functions.
+ * The sequence of objects is defined in the constructor by
+ * using the setStart and setNext functions.
  *
  *  1. Buffers with a size header inside that class can be declared with
- *     SerialFixedArrayListAdapter<BUFFER_TYPE, MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE>.
- *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements in FixedArrayList
- *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header containing the buffer size
- *     (defaults to 1 byte length field) that follows
+ *     @code
+ *     SerialFixedArrayListAdapter<BUFFER_TYPE,
+ *     		MAX_BUFFER_LENGTH, LENGTH_FIELD_TYPE> mySerialFixedArrayList(...).
+ *     @endcode
+ *  2. MAX_BUFFER_LENGTH specifies the maximum allowed number of elements
+ *     in FixedArrayList.
+ *  3. LENGTH_FIELD_TYPE specifies the data type of the buffer header
+ *     containing the buffer size (defaults to 1 byte length field)
+ *     that follows.
  *
  * @ingroup serialize
  */
 template<typename BUFFER_TYPE, uint32_t MAX_SIZE, typename count_t = uint8_t>
-class SerialFixedArrayListAdapter : public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>, public SerializeIF {
+class SerialFixedArrayListAdapter :
+		public FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>,
+		public SerializeIF {
 public:
 	/**
-	 * Constructor Arguments are forwarded to FixedArrayList constructor
+	 * Constructor Arguments are forwarded to FixedArrayList constructor.
+	 * Refer to the fixed array list constructors for different options.
 	 * @param args
 	 */
 	template<typename... Args>
-	SerialFixedArrayListAdapter(Args... args) : FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
-	}
+	SerialFixedArrayListAdapter(Args... args) :
+	FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
+	{}
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this, buffer, size, max_size, bigEndian);
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const  override {
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
+				buffer, size, max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
-		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
+		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+				getSerializedSize(this);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
+
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override {
 		return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
 				buffer, size, bigEndian);
 	}
 
 	void swapArrayListEndianness() {
-		SerialArrayListAdapter<BUFFER_TYPE, count_t>::swapArrayListEndianness(this);
+		SerialArrayListAdapter<BUFFER_TYPE, count_t>::
+				swapArrayListEndianness(this);
 	}
 };
 

serialize/SerialLinkedListAdapter.h

@@ -18,23 +18,25 @@
  * 		   	or vice-versa, using linked lists.
  * @details
  * An alternative to the AutoSerializeAdapter functions
- *   - All object members with a datatype are declared as SerializeElement<element_type>
- * 	   members inside the class implementing this adapter.
- *   - The element type can also be a SerialBufferAdapter to de-/serialize buffers,
- *     with a known size, where the size can also be serialized
- *   - The element type can also be a SerialFixedArrayListAdapter to de-/serialize buffers
- *     with a size header, which is scanned automatically
+ *   - All object members with a datatype are declared as
+ *     SerializeElement<element_type> members inside the class
+ *     implementing this adapter.
+ *   - The element type can also be a SerialBufferAdapter to
+ *     de-/serialize buffers with a known size
+ *   - The element type can also be a SerialFixedArrayListAdapter to
+ *     de-/serialize buffers with a size header, which is scanned automatically.
  *
  * The sequence of objects is defined in the constructor by using
  * the setStart and setNext functions.
  *
- * - The serialization process is done by instantiating the class and
- *   calling serializ after all SerializeElement entries have been set by
- *   using the constructor or setter functions. An additional size variable can be supplied
- *   which is calculated/incremented automatically
- * - The deserialization process is done by instantiating the class and supplying
- *   a buffer with the data which is converted into an object. The size of
- *   data to serialize can be supplied and is decremented in the function
+ * 1. The serialization process is done by instantiating the class and
+ *    calling serialize after all SerializeElement entries have been set by
+ *    using the constructor or setter functions. An additional size variable
+ *    can be supplied which is calculated/incremented automatically.
+ * 2. The deserialization process is done by instantiating the class and
+ *    supplying a buffer with the data which is converted into an object.
+ *    The size of data to serialize can be supplied and is
+ *    decremented in the function. Range checking is done internally.
  *
  * @ingroup serialize
  */
@@ -55,10 +57,12 @@ public:
 			bool printCount = false) :
 			SinglyLinkedList<T>(start), printCount(printCount) {
 	}
+
 	SerialLinkedListAdapter(LinkedElement<T>* first, bool printCount = false) :
 			SinglyLinkedList<T>(first), printCount(printCount) {
 
 	}
+
 	SerialLinkedListAdapter(bool printCount = false) :
 			SinglyLinkedList<T>(), printCount(printCount) {
 	}
@@ -66,15 +70,16 @@ public:
 	/**
 	 * Serialize object implementing this adapter into the supplied buffer
 	 * and calculate the serialized size
-	 * @param buffer [out] Object is serialized into this buffer. Note that the buffer pointer
-	 *               *buffer is incremented automatically inside the respective serialize functions
+	 * @param buffer [out] Object is serialized into this buffer.
+	 *    Note that the buffer pointer *buffer is incremented automatically
+	 *    inside the respective serialize functions
 	 * @param size [out] Calculated serialized size. Don't forget to set to 0.
 	 * @param max_size
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
 	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
+			const size_t max_size, bool bigEndian) const override{
 		if (printCount) {
 			count_t mySize = SinglyLinkedList<T>::getSize();
 			ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
@@ -98,7 +103,9 @@ public:
 		}
 		return result;
 	}
-	virtual size_t getSerializedSize() const {
+
+
+	virtual size_t getSerializedSize() const override {
 		if (printCount) {
 			return SerialLinkedListAdapter<T>::getSerializedSize()
 					+ sizeof(count_t);
@@ -106,6 +113,7 @@ public:
 			return getSerializedSize(SinglyLinkedList<T>::start);
 		}
 	}
+
 	static uint32_t getSerializedSize(const LinkedElement<T> *element) {
 		uint32_t size = 0;
 		while (element != NULL) {
@@ -115,20 +123,22 @@ public:
 		return size;
 	}
 
+
 	/**
-	 * Deserialize supplied buffer with supplied size into object implementing this adapter
+	 * Deserialize supplied buffer with supplied size into object
+	 * implementing this adapter.
 	 * @param buffer
 	 * @param size Decremented in respective deSerialize functions automatically
 	 * @param bigEndian Specify endianness
 	 * @return
 	 */
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override {
 		return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
 	}
 
 	static ReturnValue_t deSerialize(LinkedElement<T>* element,
-			const uint8_t** buffer, ssize_t* size, bool bigEndian) {
+			const uint8_t** buffer, size_t* size, bool bigEndian) {
 		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 		while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
 			result = element->value->deSerialize(buffer, size, bigEndian);
@@ -138,7 +148,6 @@ public:
 	}
 
 	bool printCount;
-
 };
 
 #endif /* SERIALLINKEDLISTADAPTER_H_ */

serialize/SerializeAdapter.h

@@ -1,135 +1,86 @@
 #ifndef SERIALIZEADAPTER_H_
 #define SERIALIZEADAPTER_H_
 
-#include <framework/container/IsDerivedFrom.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/serialize/EndianSwapper.h>
 #include <framework/serialize/SerializeIF.h>
-#include <string.h>
+#include <framework/serialize/SerializeAdapterInternal.h>
+#include <type_traits>
 
  /**
- * @brief This adapter provides an interface to use the SerializeIF functions
- * 		  with arbitrary template objects to facilitate and simplify the serialization of classes
- * 		  with different multiple different data types into buffers and vice-versa.
+ * @brief These adapters provides an interface to use the SerializeIF functions
+ * 		  with arbitrary template objects to facilitate and simplify the
+ * 		  serialization of classes with different multiple different data types
+ * 		  into buffers and vice-versa.
  * @details
- * Examples:
- * A report class is converted into a TM buffer. The report class implements a serialize functions and calls
- * the AutoSerializeAdapter::serialize function repeatedly on all object data fields.
- * The getSerializedSize function is implemented by calling the
- * AutoSerializeAdapter::getSerializedSize function repeatedly on all data fields.
  *
- * The AutoSerializeAdapter functions can also be used as an alternative to memcpy
- * to retrieve data out of a buffer directly into a class variable with data type T while being able to specify endianness.
- * The boolean bigEndian specifies whether an endian swap is performed on the data before
+ * A report class is converted into a TM buffer. The report class implements a
+ * serialize functions and calls the AutoSerializeAdapter::serialize function
+ * repeatedly on all object data fields. The getSerializedSize function is
+ * implemented by calling the AutoSerializeAdapter::getSerializedSize function
+ * repeatedly on all data fields.
+ *
+ * The AutoSerializeAdapter functions can also be used as an alternative to
+ * memcpy to retrieve data out of a buffer directly into a class variable
+ * with data type T while being able to specify endianness. The boolean
+ * bigEndian specifies whether an endian swap is performed on the data before
  * serialization or deserialization.
  *
- * If the target architecture is little endian (ARM), any data types created might
- * have the wrong endiness if they are to be used for the FSFW.
  * There are three ways to retrieve data out of a buffer to be used in the FSFW
- * to use regular aligned (big endian) data.
- * This can also be applied to uint32_t and uint64_t:
+ * to use regular aligned (big endian) data. Examples:
  *
  *   1. Use the AutoSerializeAdapter::deSerialize function
- *		The pointer *buffer will be incremented automatically by the typeSize of the object,
- *		so this function can be called on &buffer repeatedly without adjusting pointer position.
- *		Set bigEndian parameter to true to perform endian swapping.
- *
+ *		The pointer *buffer will be incremented automatically by the typeSize
+ *		 of the object, so this function can be called on &buffer repeatedly
+ *		without adjusting pointer position. Set bigEndian parameter to true
+ *		to perform endian swapping, if necessary
+ *		@code
  *   	uint16_t data;
  *   	int32_t dataLen = sizeof(data);
- *   	ReturnValue_t result = AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
- *
- *   2. Perform a bitshift operation. Perform endian swapping if necessary:
+ *   	ReturnValue_t result =
+ *   			AutoSerializeAdapter::deSerialize(&data,&buffer,&dataLen,true);
+ *   	@endcode
  *
+ *   2. Perform a bitshift operation. Watch for for endianness:
+ *		@code
  *   	uint16_t data;
  *   	data = buffer[targetByte1] << 8 | buffer[targetByte2];
- *   	data = EndianSwapper::swap(data);
- *
- *   3. Memcpy can be used when data is little-endian. Perform endian-swapping if necessary.
+ *   	data = EndianSwapper::swap(data); //optional, or swap order above
+ *   	@endcode
  *
+ *   3. memcpy or std::copy can also be used, but watch out if system
+ *   	endianness is different from required data endianness.
+ *   	Perform endian-swapping if necessary.
+ *		@code
  *   	uint16_t data;
  *   	memcpy(&data,buffer + positionOfTargetByte1,sizeof(data));
- *   	data = EndianSwapper::swap(data);
+ *   	data = EndianSwapper::swap(data); //optional
+ *   	@endcode
  *
- * When serializing for downlink, the packets are generally serialized assuming big endian data format
- * like seen in TmPacketStored.cpp for example.
+ * When serializing for downlink, the packets are generally serialized assuming
+ * big endian data format like seen in TmPacketStored.cpp for example.
  *
  * @ingroup serialize
  */
-template<typename T, int>
-class SerializeAdapter_ {
+
+// No type specification necessary here.
+class AutoSerializeAdapter {
 public:
+	template<typename T>
 	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
 			size_t* size, const size_t max_size, bool bigEndian) {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		if (sizeof(T) + *size <= max_size) {
-			T tmp;
-			if (bigEndian) {
-				tmp = EndianSwapper::swap<T>(*object);
-			} else {
-				tmp = *object;
-			}
-			memcpy(*buffer, &tmp, sizeof(T));
-			*size += sizeof(T);
-			(*buffer) += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::BUFFER_TOO_SHORT;
-		}
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.serialize(object, buffer, size, max_size, bigEndian);
 	}
-
-	/**
-	 * Deserialize buffer into object
-	 * @param object [out] Object to be deserialized with buffer data
-	 * @param buffer buffer containing the data. Non-Const pointer to non-const pointer to const buffer.
-	 * @param size int32_t type to allow value to be values smaller than 0, needed for range/size checking
-	 * @param bigEndian Specify endianness
-	 * @return
-	 */
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
-		T tmp;
-		*size -= sizeof(T);
-		if (*size >= 0) {
-			memcpy(&tmp, *buffer, sizeof(T));
-			if (bigEndian) {
-				*object = EndianSwapper::swap<T>(tmp);
-			} else {
-				*object = tmp;
-			}
-			*buffer += sizeof(T);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return SerializeIF::STREAM_TOO_SHORT;
-		}
+	template<typename T>
+	static size_t getSerializedSize(const T* object) {
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.getSerializedSize(object);
 	}
-
-	uint32_t getSerializedSize(const T * object) {
-		return sizeof(T);
-	}
-
-};
-
-template<typename T>
-class SerializeAdapter_<T, 1> {
-public:
-	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		size_t ignoredSize = 0;
-		if (size == NULL) {
-			size = &ignoredSize;
-		}
-		return object->serialize(buffer, size, max_size, bigEndian);
-	}
-	uint32_t getSerializedSize(const T* object) const {
-		return object->getSerializedSize();
-	}
-
-	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
-		return object->deSerialize(buffer, size, bigEndian);
+	template<typename T>
+	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
+			size_t* size, bool bigEndian) {
+		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
+		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}
 };
 
@@ -147,29 +98,7 @@ public:
 	}
 
 	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			ssize_t* size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.deSerialize(object, buffer, size, bigEndian);
-	}
-};
-
-// No type specification necessary here.
-class AutoSerializeAdapter {
-public:
-	template<typename T>
-	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
-			size_t* size, const size_t max_size, bool bigEndian) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.serialize(object, buffer, size, max_size, bigEndian);
-	}
-	template<typename T>
-	static uint32_t getSerializedSize(const T* object) {
-		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
-		return adapter.getSerializedSize(object);
-	}
-	template<typename T>
-	static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
-			ssize_t* size, bool bigEndian) {
+			size_t* size, bool bigEndian) {
 		SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
 		return adapter.deSerialize(object, buffer, size, bigEndian);
 	}

serialize/SerializeAdapterInternal.h

@@ -0,0 +1,118 @@
+/**
+ * @file 	SerializeAdapterInternal.h
+ *
+ * @date	13.04.2020
+ * @author	R. Mueller
+ */
+
+#ifndef FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
+#define FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/IsDerivedFrom.h>
+#include <framework/serialize/EndianSwapper.h>
+
+/**
+ * This template specialization will be chosen for fundamental types or
+ * anything else not implementing SerializeIF, based on partial
+ * template specialization.
+ * @tparam T
+ * @tparam
+ */
+template<typename T, int>
+class SerializeAdapter_ {
+public:
+	/**
+	 *
+	 * @param object
+	 * @param buffer
+	 * @param size
+	 * @param max_size
+	 * @param bigEndian
+	 * @return
+	 */
+	static ReturnValue_t serialize(const T* object, uint8_t** buffer,
+			size_t* size, const size_t max_size, bool bigEndian) {
+	    // function eventuelly serializes structs here.
+	    // does this work on every architecture?
+	    // static_assert(std::is_fundamental<T>::value);
+		size_t ignoredSize = 0;
+		if (size == nullptr) {
+			size = &ignoredSize;
+		}
+		if (sizeof(T) + *size <= max_size) {
+			T tmp;
+			if (bigEndian) {
+				tmp = EndianSwapper::swap<T>(*object);
+			} else {
+				tmp = *object;
+			}
+			memcpy(*buffer, &tmp, sizeof(T));
+			*size += sizeof(T);
+			(*buffer) += sizeof(T);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return SerializeIF::BUFFER_TOO_SHORT;
+		}
+	}
+
+	/**
+	 * Deserialize buffer into object
+	 * @param object [out] Object to be deserialized with buffer data
+	 * @param buffer contains the data. Non-Const pointer to non-const
+	 * 				 pointer to const data.
+	 * @param size Size to deSerialize. wil be decremented by sizeof(T)
+	 * @param bigEndian Specify endianness
+	 * @return
+	 */
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
+			bool bigEndian) {
+		T tmp;
+		if (*size >= sizeof(T)) {
+			*size -= sizeof(T);
+			memcpy(&tmp, *buffer, sizeof(T));
+			if (bigEndian) {
+				*object = EndianSwapper::swap<T>(tmp);
+			} else {
+				*object = tmp;
+			}
+			*buffer += sizeof(T);
+			return HasReturnvaluesIF::RETURN_OK;
+		} else {
+			return SerializeIF::STREAM_TOO_SHORT;
+		}
+	}
+
+	size_t getSerializedSize(const T * object) {
+		return sizeof(T);
+	}
+};
+
+/**
+ * This template specialization will be chosen for class derived from
+ * SerializeIF, based on partial template specialization.
+ * @tparam T
+ * @tparam
+ */
+template<typename T>
+class SerializeAdapter_<T, true> {
+public:
+	ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const {
+		size_t ignoredSize = 0;
+		if (size == NULL) {
+			size = &ignoredSize;
+		}
+		return object->serialize(buffer, size, max_size, bigEndian);
+	}
+
+	size_t getSerializedSize(const T* object) const {
+		return object->getSerializedSize();
+	}
+
+	ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
+			bool bigEndian) {
+		return object->deSerialize(buffer, size, bigEndian);
+	}
+};
+
+#endif /* FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_ */

serialize/SerializeElement.h

@@ -24,25 +24,26 @@ public:
 	 * @param args
 	 */
 	template<typename... Args>
-	SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
+	SerializeElement(Args... args):
+			LinkedElement<SerializeIF>(this),
+			entry(std::forward<Args>(args)...) {}
 
-	}
-	SerializeElement() : LinkedElement<SerializeIF>(this) {
-	}
+	SerializeElement() : LinkedElement<SerializeIF>(this) {}
 
 	T entry;
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			const size_t max_size, bool bigEndian) const {
-		return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian);
+	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+			const size_t max_size, bool bigEndian) const override {
+		return SerializeAdapter<T>::serialize(&entry, buffer, size,
+				max_size, bigEndian);
 	}
 
 	size_t getSerializedSize() const {
 		return SerializeAdapter<T>::getSerializedSize(&entry);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
-			bool bigEndian) {
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			bool bigEndian) override {
 		return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
 	}
 

serialize/SerializeIF.h

@@ -3,11 +3,6 @@
 
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <cstddef>
-#include <type_traits>
-
-#ifndef ssize_t
-typedef std::make_signed<std::size_t>::type ssize_t;
-#endif
 
 /**
  * @defgroup serialize Serialization
@@ -18,17 +13,21 @@ typedef std::make_signed<std::size_t>::type ssize_t;
  * @brief An interface for alle classes which require
  *        translation of objects data into data streams and vice-versa.
  * @details
- * If the target architecture is little endian (e.g. ARM), any data types created might
- * have the wrong endiness if they are to be used for the FSFW.
- * There are three ways to retrieve data out of a buffer to be used in the FSFW to use
- * regular aligned (big endian) data. This can also be applied to uint32_t and uint64_t:
+ * If the target architecture is little endian (e.g. ARM), any data types
+ * created might  have the wrong endianess if they are to be used for the FSFW.
+ * Depending on the system architecture, endian correctness must be assured,
+ * This is important for incoming and outgoing data. The internal handling
+ * of data should be performed in the native system endianness.
+ * There are three ways to copy data (with different options to ensure
+ * endian correctness):
  *
- *   1. Use the @c AutoSerializeAdapter::deSerialize function with @c bigEndian = true
- *   2. Perform a bitshift operation
- *   3. @c memcpy can be used when data is in little-endian format. Otherwise, @c EndianSwapper has to be used in conjuction.
+ *   1. Use the @c AutoSerializeAdapter::deSerialize function (with
+ *      the endian flag)
+ *   2. Perform a bitshift operation (with correct order)
+ *   3. @c memcpy (with @c EndianSwapper if necessary)
  *
- * When serializing for downlink, the packets are generally serialized assuming big endian data format
- * like seen in TmPacketStored.cpp for example.
+ * When serializing for downlink, the packets are generally serialized
+ * assuming big endian data format like seen in TmPacketStored.cpp for example.
  *
  * @ingroup serialize
  */
@@ -47,7 +46,7 @@ public:
 
 	virtual size_t getSerializedSize() const = 0;
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) = 0;
 
 };

serviceinterface/ServiceInterfaceBuffer.cpp

@@ -1,13 +1,10 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <cstring>
-#include <inttypes.h>
 
 // to be implemented by bsp
 extern "C" void printChar(const char*);
 
-
-
 int ServiceInterfaceBuffer::overflow(int c) {
 	// Handle output
 	putChars(pbase(), pptr());
@@ -26,15 +23,16 @@ int ServiceInterfaceBuffer::sync(void) {
 	if (this->isActive) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
-		char preamble[96] = { 0 };
-		sprintf(preamble, "%s: | %" PRIu32 ":%02" PRIu32 ":%02" PRIu32 ".%03" PRIu32 " | ",
-				this->log_message.c_str(),
-				loggerTime.hour,
-				loggerTime.minute,
-				loggerTime.second,
-				loggerTime.usecond /1000);
+		std::string preamble;
+		if(addCrToPreamble) {
+			preamble += "\r";
+		}
+		preamble += log_message + ": | " + zero_padded(loggerTime.hour, 2)
+				+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+				+ zero_padded(loggerTime.second, 2) + "."
+				+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
 		// Write log_message and time
-		this->putChars(preamble, preamble + sizeof(preamble));
+		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
 		// Handle output
 		this->putChars(pbase(), pptr());
 	}
@@ -43,9 +41,13 @@ int ServiceInterfaceBuffer::sync(void) {
 	return 0;
 }
 
+
+
 #ifndef UT699
 
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+        uint16_t port, bool addCrToPreamble) {
+	this->addCrToPreamble = addCrToPreamble;
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
@@ -59,17 +61,22 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 	}
 	memcpy(array, begin, length);
 
-	for( ; begin != end; begin++){
+	for(; begin != end; begin++){
 		printChar(begin);
 	}
 
 }
 #endif
 
+/**
+ * TODO: This is architecture specific. Maybe there is a better solution
+ * to move this into the Bsp folder..
+ */
 #ifdef UT699
 #include <framework/osal/rtems/Interrupt.h>
 
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) {
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );

serviceinterface/ServiceInterfaceBuffer.h

@@ -2,32 +2,36 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
 #include <iostream>
-#include <iosfwd>
 #include <sstream>
 #include <cstdio>
+#include <iomanip>
 
 #ifndef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
+class ServiceInterfaceBuffer:
+        public std::basic_streambuf<char,std::char_traits<char>> {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port,
+			bool addCrToPreamble);
 protected:
 	bool isActive;
 	// This is called when buffer becomes full. If
 	// buffer is not used, then this is called every
 	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
+	int overflow(int c = Traits::eof()) override;
 
 	// This function is called when stream is flushed,
 	// for example when std::endl is put to stream.
-	virtual int sync(void);
+	int sync(void) override;
 
 private:
 	// For additional message information
 	std::string log_message;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
+	// This is useful for some terminal programs which do not have
+	// implicit carriage return with newline characters.
+	bool addCrToPreamble;
 
 	// Work in buffer mode. It is also possible to work without buffer.
 	static size_t const BUF_SIZE = 128;
@@ -35,6 +39,18 @@ private:
 
 	// In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
+
+	template<typename T>
+	std::string zero_padded(const T& num, uint8_t width) {
+	    std::ostringstream string_to_pad;
+	    string_to_pad << std::setw(width) << std::setfill('0') << num;
+	    std::string result = string_to_pad.str();
+	    if (result.length() > width)
+	    {
+	        result.erase(0, result.length() - width);
+	    }
+	    return result;
+	}
 };
 #endif
 

serviceinterface/ServiceInterfaceStream.cpp

@@ -5,7 +5,7 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 }
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
-		uint16_t port) :
-		std::basic_ostream<char, std::char_traits<char> >(&buf), buf(
-				set_message, port) {
+		bool addCrToPreamble, uint16_t port) :
+		std::basic_ostream<char, std::char_traits<char>>(&buf),
+		buf(set_message, port, addCrToPreamble) {
 }

serviceinterface/ServiceInterfaceStream.h

@@ -7,21 +7,22 @@
 #include <sstream>
 #include <cstdio>
 
-//Unfortunately, there must be a forward declaration of log_fe
+// Unfortunately, there must be a forward declaration of log_fe
 // (MUST be defined in main), to let the system know where to write to.
 extern std::ostream debug;
 extern std::ostream info;
 extern std::ostream warning;
 extern std::ostream error;
 
-class ServiceInterfaceStream : public std::basic_ostream< char, std::char_traits< char > > {
+class ServiceInterfaceStream :
+        public std::basic_ostream<char, std::char_traits<char>> {
 protected:
     ServiceInterfaceBuffer buf;
 public:
-    ServiceInterfaceStream( std::string set_message, uint16_t port = 1234 );
+    ServiceInterfaceStream( std::string set_message,
+    		bool addCrToPreamble = false, uint16_t port = 1234);
 	void setActive( bool );
 };
 
 
-
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

storagemanager/StorageManagerIF.h

@@ -144,7 +144,8 @@ public:
 	 * 					@li	RETURN_FAILED if data could not be added.
 	 * 						storageId is unchanged then.
 	 */
-	virtual ReturnValue_t getFreeElement(store_address_t* storageId, const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
+	virtual ReturnValue_t getFreeElement(store_address_t* storageId,
+			const uint32_t size, uint8_t** p_data, bool ignoreFault = false ) = 0;
 	/**
 	 * Clears the whole store.
 	 * Use with care!

subsystem/Subsystem.cpp

@@ -168,7 +168,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				&sizeRead);
 		if (result == RETURN_OK) {
 			Mode_t fallbackId;
-			ssize_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {
@@ -193,7 +193,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
 				ModeSequenceMessage::getStoreAddress(message), &pointer,
 				&sizeRead);
 		if (result == RETURN_OK) {
-			ssize_t size = sizeRead;
+			size_t size = sizeRead;
 			result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
 					&pointer, &size, true);
 			if (result == RETURN_OK) {

subsystem/modes/ModeDefinitions.h

@@ -53,7 +53,7 @@ public:
 		return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
 	}
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result;
 

test/CatchExample.cpp

@@ -0,0 +1,51 @@
+// Catch Example.
+// Does not work yet. Problems with linker without main and config folder.
+// propably because global object manager and some config files are not supplied
+// but mandatory for full compilation of the framework.
+// Let Catch provide main():
+
+#if defined(UNIT_TEST)
+#define CATCH_CONFIG_MAIN
+
+#include <framework/test/catch2/catch.hpp>
+#include <framework/test/UnitTestClass.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+int Factorial( int number ) {
+   return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
+// return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
+}
+
+
+
+TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
+    REQUIRE( Factorial(0) == 1 );
+}
+
+TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
+    REQUIRE( Factorial(1) == 1 );
+    REQUIRE( Factorial(2) == 2 );
+    REQUIRE( Factorial(3) == 6 );
+    REQUIRE( Factorial(10) == 3628800 );
+}
+
+TEST_CASE( "Custom test", "[single-file]" ) {
+    UnitTestClass unitTestClass;
+    REQUIRE( unitTestClass.test_autoserialization() == HasReturnvaluesIF::RETURN_OK );
+}
+
+// Compile & run:
+// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && ./010-TestCase --success
+// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 010-TestCase.cpp && 010-TestCase --success
+
+// Expected compact output (all assertions):
+//
+// prompt> 010-TestCase --reporter compact --success
+// 010-TestCase.cpp:14: failed: Factorial(0) == 1 for: 0 == 1
+// 010-TestCase.cpp:18: passed: Factorial(1) == 1 for: 1 == 1
+// 010-TestCase.cpp:19: passed: Factorial(2) == 2 for: 2 == 2
+// 010-TestCase.cpp:20: passed: Factorial(3) == 6 for: 6 == 6
+// 010-TestCase.cpp:21: passed: Factorial(10) == 3628800 for: 3628800 (0x375f00) == 3628800 (0x375f00)
+// Failed 1 test case, failed 1 assertion.
+
+#endif

test/UnitTestClass.cpp

@@ -0,0 +1,302 @@
+/**
+ * @file 	UnitTestClass.cpp
+ *
+ * @date 	11.04.2020
+ * @author 	R. Mueller
+ */
+#include <framework/test/UnitTestClass.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/serialize/SerializeElement.h>
+#include <framework/serialize/SerialBufferAdapter.h>
+
+#include <cstdlib>
+
+#if defined(UNIT_TEST)
+#include "catch.hpp"
+#define CATCH_CONFIG_MAIN
+
+TEST_CASE( "Serialization Size tests", "[single-file]") {
+   //REQUIRE(UnitTestClass::test_serialization == RETURN_OK );
+}
+#endif
+
+UnitTestClass::UnitTestClass() {}
+
+UnitTestClass::~UnitTestClass() {}
+
+ReturnValue_t UnitTestClass::perform_tests() {
+	ReturnValue_t result = test_serialization();
+	if(result != RETURN_OK) {
+		return result;
+	}
+
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_serialization() {
+	// Here, we test all serialization tools. First test basic cases.
+	ReturnValue_t result = test_endianness_tools();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	result = test_autoserialization();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	result = test_serial_buffer_adapter();
+	if(result != RETURN_OK) {
+		return result;
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_endianness_tools() {
+	test_array[0] = 0;
+	test_array[1] = 0;
+	uint16_t two_byte_value = 1;
+	size_t size = 0;
+	uint8_t* p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, false);
+	// Little endian: Value one on first byte
+	if(test_array[0] != 1 and test_array[1] != 0) {
+		return put_error(TestIds::ENDIANNESS_TOOLS);
+
+	}
+
+	p_array = test_array.data();
+	size = 0;
+	AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, true);
+	// Big endian: Value one on second byte
+	if(test_array[0] != 0 and test_array[1] != 1) {
+		return put_error(TestIds::ENDIANNESS_TOOLS);
+	}
+
+	// Endianness paameter will be changed later.
+//	p_array = test_array.data();
+//	ssize_t ssize = size;
+//	// Resulting parameter should be big endian
+//	AutoSerializeAdapter::deSerialize(&two_byte_value,
+//			const_cast<const uint8_t **>(&p_array), &ssize, true);
+//	if(two_byte_value != 1) {
+//		return put_error(TestIds::ENDIANNESS_TOOLS);
+//	}
+//
+//	ssize = size;
+//	p_array = test_array.data();
+//	// Resulting parameter should be little endian
+//	AutoSerializeAdapter::deSerialize(&two_byte_value,
+//			const_cast<const uint8_t **>(&p_array), &ssize, false);
+//	if(two_byte_value != 256) {
+//		return put_error(TestIds::ENDIANNESS_TOOLS);
+//	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::test_autoserialization() {
+	current_id = TestIds::AUTO_SERIALIZATION_SIZE;
+	// Unit Test getSerializedSize
+	if(AutoSerializeAdapter::
+			getSerializedSize(&test_value_bool) != sizeof(test_value_bool) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint8) != sizeof(tv_uint8) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint16) != sizeof(tv_uint16) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint32) != sizeof(tv_uint32) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_uint64) != sizeof(tv_uint64) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int8) != sizeof(tv_int8) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_double) != sizeof(tv_double) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int16) != sizeof(tv_int16) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_int32) != sizeof(tv_int32) or
+			AutoSerializeAdapter::
+			getSerializedSize(&tv_float) != sizeof(tv_float))
+	{
+		return put_error(current_id);
+	}
+
+	// Unit Test AutoSerializeAdapter deserialize
+	current_id = TestIds::AUTO_SERIALIZATION_SERIALIZE;
+
+	size_t serialized_size = 0;
+	uint8_t * p_array = test_array.data();
+
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint8, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint32, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int8, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int16, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_int32, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint64, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_float, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_double, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_sfloat, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_sdouble, &p_array,
+			&serialized_size, test_array.size(), false);
+	// expected size is 1 + 1 + 2 + 4 + 1 + 2 + 4 + 8 + 4 + 8 + 4 + 8
+	if(serialized_size != 47) {
+		return put_error(current_id);
+	}
+
+	// Unit Test AutoSerializeAdapter serialize
+	current_id = TestIds::AUTO_SERIALIZATION_DESERIALIZE;
+	p_array = test_array.data();
+	size_t remaining_size = serialized_size;
+	AutoSerializeAdapter::deSerialize(&test_value_bool,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int8,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int16,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_int32,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_uint64,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_float,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_double,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_sfloat,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+	AutoSerializeAdapter::deSerialize(&tv_sdouble,
+			const_cast<const uint8_t**>(&p_array), &remaining_size, false);
+
+	if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
+			tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
+			tv_int16 != -829 or tv_int32 != -2312)
+	{
+		return put_error(current_id);
+	}
+
+	// These epsilon values were just guessed.. It appears to work though.
+	if(abs(tv_float - 8.214921) > 0.0001 or
+			abs(tv_double - 9.2132142141e8) > 0.01 or
+			abs(tv_sfloat - (-922.2321321)) > 0.0001 or
+			abs(tv_sdouble - (-2.2421e19)) > 0.01) {
+		return put_error(current_id);
+	}
+
+	// Check overflow
+	return RETURN_OK;
+}
+
+// TODO: Also test for constant buffers.
+ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
+	current_id = TestIds::SERIALIZATION_BUFFER_ADAPTER;
+
+	// I will skip endian swapper testing, its going to be changed anyway..
+	// uint8_t tv_uint8_swapped = EndianSwapper::swap(tv_uint8);
+
+	size_t serialized_size = 0;
+	test_value_bool = true;
+	uint8_t * p_array = test_array.data();
+	std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), false);
+	tv_uint16 = 16;
+
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
+			or test_array[5] != 1)
+	{
+		return put_error(current_id);
+	}
+	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+
+	// Serialize with size field
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter2 =
+			SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
+					test_serial_buffer.size(), true);
+	serialized_size = 0;
+	p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter2, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 9 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 5 or test_array[3] != 4 or test_array[4] != 3
+			or test_array[5] != 2 or test_array[6] != 1)
+	{
+		return put_error(current_id);
+	}
+	memcpy(&tv_uint16, test_array.data() + 7, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+
+	// Serialize with size field
+	SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter3 =
+			SerialBufferAdapter<uint8_t>(
+			const_cast<const uint8_t*>(test_serial_buffer.data()),
+			test_serial_buffer.size(), false);
+	serialized_size = 0;
+	p_array = test_array.data();
+	AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
+			test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter3, &p_array,
+			&serialized_size, test_array.size(), false);
+	AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
+			test_array.size(), false);
+
+	if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
+			or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
+			or test_array[5] != 1)
+	{
+		return put_error(current_id);
+	}
+	memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
+	if(tv_uint16 != 16) {
+		return put_error(current_id);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t UnitTestClass::put_error(TestIds currentId) {
+	auto errorIter = testResultMap.find(currentId);
+	if(errorIter != testResultMap.end()) {
+		testResultMap.emplace(currentId, 1);
+	}
+	else {
+		errorIter->second ++;
+	}
+	error << "Unit Tester failed at test ID "
+			<< static_cast<uint32_t>(currentId) << "\r\n" << std::flush;
+	return RETURN_FAILED;
+}
+

test/UnitTestClass.h

@@ -0,0 +1,84 @@
+/**
+ * @file 	UnitTestClass.h
+ *
+ * @date 	11.04.2020
+ * @author 	R. Mueller
+ */
+
+#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
+#define FRAMEWORK_TEST_UNITTESTCLASS_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+
+#include <map>
+#include <vector>
+
+/**
+ * We could start doing basic forms of Unit Testing (without a framework, first)
+ * for framework components. This could include:
+ *
+ *  1. TMTC Services
+ *  2. Serialization tools
+ *  3. Framework internal algorithms
+ *
+ *  TODO: Maybe use specialized framework.
+ */
+
+class UnitTestClass: public HasReturnvaluesIF {
+public:
+	UnitTestClass();
+	virtual~ UnitTestClass();
+
+	enum class TestIds {
+		ENDIANNESS_TOOLS,
+		AUTO_SERIALIZATION_SIZE,
+		AUTO_SERIALIZATION_SERIALIZE,
+		AUTO_SERIALIZATION_DESERIALIZE ,
+		SERIALIZATION_BUFFER_ADAPTER,
+		SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER,
+		SERIALIZATION_COMBINATION,
+		TMTC_SERVICES ,
+		MISC
+	};
+
+	/**
+	 * Some function which calls all other tests
+	 * @return
+	 */
+	ReturnValue_t perform_tests();
+
+	ReturnValue_t test_serialization();
+	ReturnValue_t test_autoserialization();
+	ReturnValue_t test_serial_buffer_adapter();
+	ReturnValue_t test_endianness_tools();
+private:
+	uint32_t errorCounter = 0;
+	TestIds current_id = TestIds::MISC;
+	std::array<uint8_t, 512> test_array;
+
+	using error_count_t =  uint8_t;
+	using TestResultMap = std::map<TestIds, error_count_t>;
+	using TestBuffer = std::vector<uint8_t>;
+	TestResultMap testResultMap;
+
+	// POD test values
+	bool test_value_bool = true;
+	uint8_t tv_uint8   {5};
+	uint16_t tv_uint16 {283};
+	uint32_t tv_uint32 {929221};
+	uint64_t tv_uint64 {2929329429};
+
+	int8_t tv_int8 {-16};
+	int16_t tv_int16 {-829};
+	int32_t tv_int32 {-2312};
+
+	float tv_float {8.2149214};
+	float tv_sfloat = {-922.2321321};
+	double tv_double {9.2132142141e8};
+	double tv_sdouble {-2.2421e19};
+
+	ReturnValue_t put_error(TestIds currentId);
+};
+
+
+#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */

test/catch2/catch_reporter_automake.hpp

@@ -0,0 +1,62 @@
+/*
+ *  Created by Justin R. Wilson on 2/19/2017.
+ *  Copyright 2017 Justin R. Wilson. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+namespace Catch {
+
+    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
+        AutomakeReporter( ReporterConfig const& _config )
+          :   StreamingReporterBase( _config )
+        {}
+
+        ~AutomakeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the format of Automake .trs files";
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
+
+        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
+            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+            stream << ":test-result: ";
+            if (_testCaseStats.totals.assertions.allPassed()) {
+                stream << "PASS";
+            } else if (_testCaseStats.totals.assertions.allOk()) {
+                stream << "XFAIL";
+            } else {
+                stream << "FAIL";
+            }
+            stream << ' ' << _testCaseStats.testInfo.name << '\n';
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+        }
+
+        void skipTest( TestCaseInfo const& testInfo ) override {
+            stream << ":test-result: SKIP " << testInfo.name << '\n';
+        }
+
+    };
+
+#ifdef CATCH_IMPL
+    AutomakeReporter::~AutomakeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED

test/catch2/catch_reporter_sonarqube.hpp

@@ -0,0 +1,181 @@
+/*
+ *  Created by Daniel Garcia on 2018-12-04.
+ *  Copyright Social Point SL. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <map>
+
+namespace Catch {
+
+    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
+
+        SonarQubeReporter(ReporterConfig const& config)
+        : CumulativeReporterBase(config)
+        , xml(config.stream()) {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+        ~SonarQubeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the Generic Test Data SonarQube XML format";
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void noMatchingTestCases(std::string const& /*spec*/) override {}
+
+        void testRunStarting(TestRunInfo const& testRunInfo) override {
+            CumulativeReporterBase::testRunStarting(testRunInfo);
+            xml.startElement("testExecutions");
+            xml.writeAttribute("version", "1");
+        }
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            CumulativeReporterBase::testGroupEnded(testGroupStats);
+            writeGroup(*m_testGroups.back());
+        }
+
+        void testRunEndedCumulative() override {
+            xml.endElement();
+        }
+
+        void writeGroup(TestGroupNode const& groupNode) {
+            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
+            for(auto const& child : groupNode.children)
+                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
+
+            for(auto const& kv : testsPerFile)
+                writeTestFile(kv.first.c_str(), kv.second);
+        }
+
+        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
+            XmlWriter::ScopedElement e = xml.scopedElement("file");
+            xml.writeAttribute("path", filename);
+
+            for(auto const& child : testCaseNodes)
+                writeTestCase(*child);
+        }
+
+        void writeTestCase(TestCaseNode const& testCaseNode) {
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert(testCaseNode.children.size() == 1);
+            SectionNode const& rootSection = *testCaseNode.children.front();
+            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
+        }
+
+        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+            std::string name = trim(sectionNode.stats.sectionInfo.name);
+            if(!rootName.empty())
+                name = rootName + '/' + name;
+
+            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
+                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+                xml.writeAttribute("name", name);
+                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+                writeAssertions(sectionNode, okToFail);
+            }
+
+            for(auto const& childNode : sectionNode.childSections)
+                writeSection(name, *childNode, okToFail);
+        }
+
+        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+            for(auto const& assertion : sectionNode.assertions)
+                writeAssertion( assertion, okToFail);
+        }
+
+        void writeAssertion(AssertionStats const& stats, bool okToFail) {
+            AssertionResult const& result = stats.assertionResult;
+            if(!result.isOk()) {
+                std::string elementName;
+                if(okToFail) {
+                    elementName = "skipped";
+                }
+                else {
+                    switch(result.getResultType()) {
+                        case ResultWas::ThrewException:
+                        case ResultWas::FatalErrorCondition:
+                            elementName = "error";
+                            break;
+                        case ResultWas::ExplicitFailure:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::ExpressionFailed:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::DidntThrowException:
+                            elementName = "failure";
+                            break;
+
+                            // We should never see these here:
+                        case ResultWas::Info:
+                        case ResultWas::Warning:
+                        case ResultWas::Ok:
+                        case ResultWas::Unknown:
+                        case ResultWas::FailureBit:
+                        case ResultWas::Exception:
+                            elementName = "internalError";
+                            break;
+                    }
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+                ReusableStringStream messageRss;
+                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
+                xml.writeAttribute("message", messageRss.str());
+
+                ReusableStringStream textRss;
+                if (stats.totals.assertions.total() > 0) {
+                    textRss << "FAILED:\n";
+                    if (result.hasExpression()) {
+                        textRss << "\t" << result.getExpressionInMacro() << "\n";
+                    }
+                    if (result.hasExpandedExpression()) {
+                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
+                    }
+                }
+
+                if(!result.getMessage().empty())
+                    textRss << result.getMessage() << "\n";
+
+                for(auto const& msg : stats.infoMessages)
+                    if(msg.type == ResultWas::Info)
+                        textRss << msg.message << "\n";
+
+                textRss << "at " << result.getSourceInfo();
+                xml.writeText(textRss.str(), XmlFormatting::Newline);
+            }
+        }
+
+    private:
+        XmlWriter xml;
+    };
+
+#ifdef CATCH_IMPL
+    SonarQubeReporter::~SonarQubeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED

test/catch2/catch_reporter_tap.hpp

@@ -0,0 +1,253 @@
+/*
+ *  Created by Colton Wolkins on 2015-08-15.
+ *  Copyright 2015 Martin Moene. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <algorithm>
+
+namespace Catch {
+
+    struct TAPReporter : StreamingReporterBase<TAPReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~TAPReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in TAP format, suitable for test harnesses";
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        void noMatchingTestCases( std::string const& spec ) override {
+            stream << "# No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& _assertionStats ) override {
+            ++counter;
+
+            stream << "# " << currentTestCaseInfo->name << std::endl;
+            AssertionPrinter printer( stream, _assertionStats, counter );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        void testRunEnded( TestRunStats const& _testRunStats ) override {
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        std::size_t counter = 0;
+        class AssertionPrinter {
+        public:
+            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
+            AssertionPrinter( AssertionPrinter const& ) = delete;
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
+            : stream( _stream )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( true )
+            , counter(_counter)
+            {}
+
+            void print() {
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if (result.isOk()) {
+                            printResultType(passedString());
+                        } else {
+                            printResultType(failedString());
+                        }
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if (result.isOk()) {
+                            printIssue(" # TODO");
+                        }
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+            static const char* failedString() { return "not ok"; }
+            static const char* passedString() { return "ok"; }
+
+            void printSourceInfo() const {
+                Colour colourGuard( dimColour() );
+                stream << result.getSourceInfo() << ":";
+            }
+
+            void printResultType( std::string const& passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    stream << passOrFail << ' ' << counter << " -";
+                }
+            }
+
+            void printIssue( std::string const& issue ) const {
+                stream << " " << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ";";
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << " " << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    std::string expr = result.getExpandedExpression();
+                    std::replace( expr.begin(), expr.end(), '\n', ' ');
+                    stream << expr;
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << "'";
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if (itMessage == messages.end()) {
+                    return;
+                }
+
+                // using messages.end() directly (or auto) yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ":";
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << "'";
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+            std::size_t counter;
+        };
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "1..0 # Skipped: No tests ran.";
+            } else {
+                stream << "1.." << counter;
+            }
+        }
+    };
+
+#ifdef CATCH_IMPL
+    TAPReporter::~TAPReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED

test/catch2/catch_reporter_teamcity.hpp

@@ -0,0 +1,219 @@
+/*
+ *  Created by Phil Nash on 19th December 2014
+ *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <cstring>
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
+        TeamCityReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        static std::string escape( std::string const& str ) {
+            std::string escaped = str;
+            replaceInPlace( escaped, "|", "||" );
+            replaceInPlace( escaped, "'", "|'" );
+            replaceInPlace( escaped, "\n", "|n" );
+            replaceInPlace( escaped, "\r", "|r" );
+            replaceInPlace( escaped, "[", "|[" );
+            replaceInPlace( escaped, "]", "|]" );
+            return escaped;
+        }
+        ~TeamCityReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results as TeamCity service messages";
+        }
+
+        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
+        }
+
+        void noMatchingTestCases( std::string const& /* spec */ ) override {}
+
+        void testGroupStarting( GroupInfo const& groupInfo ) override {
+            StreamingReporterBase::testGroupStarting( groupInfo );
+            stream << "##teamcity[testSuiteStarted name='"
+                << escape( groupInfo.name ) << "']\n";
+        }
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            stream << "##teamcity[testSuiteFinished name='"
+                << escape( testGroupStats.groupInfo.name ) << "']\n";
+        }
+
+
+        void assertionStarting( AssertionInfo const& ) override {}
+
+        bool assertionEnded( AssertionStats const& assertionStats ) override {
+            AssertionResult const& result = assertionStats.assertionResult;
+            if( !result.isOk() ) {
+
+                ReusableStringStream msg;
+                if( !m_headerPrintedForThisSection )
+                    printSectionHeader( msg.get() );
+                m_headerPrintedForThisSection = true;
+
+                msg << result.getSourceInfo() << "\n";
+
+                switch( result.getResultType() ) {
+                    case ResultWas::ExpressionFailed:
+                        msg << "expression failed";
+                        break;
+                    case ResultWas::ThrewException:
+                        msg << "unexpected exception";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        msg << "fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        msg << "no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        msg << "explicit failure";
+                        break;
+
+                    // We shouldn't get here because of the isOk() test
+                    case ResultWas::Ok:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                        CATCH_ERROR( "Internal error in TeamCity reporter" );
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        CATCH_ERROR( "Not implemented" );
+                }
+                if( assertionStats.infoMessages.size() == 1 )
+                    msg << " with message:";
+                if( assertionStats.infoMessages.size() > 1 )
+                    msg << " with messages:";
+                for( auto const& messageInfo : assertionStats.infoMessages )
+                    msg << "\n  \"" << messageInfo.message << "\"";
+
+
+                if( result.hasExpression() ) {
+                    msg <<
+                        "\n  " << result.getExpressionInMacro() << "\n"
+                        "with expansion:\n" <<
+                        "  " << result.getExpandedExpression() << "\n";
+                }
+
+                if( currentTestCaseInfo->okToFail() ) {
+                    msg << "- failure ignore as test marked as 'ok to fail'\n";
+                    stream << "##teamcity[testIgnored"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+                else {
+                    stream << "##teamcity[testFailed"
+                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
+                           << " message='" << escape( msg.str() ) << "'"
+                           << "]\n";
+                }
+            }
+            stream.flush();
+            return true;
+        }
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            m_headerPrintedForThisSection = false;
+            StreamingReporterBase::sectionStarting( sectionInfo );
+        }
+
+        void testCaseStarting( TestCaseInfo const& testInfo ) override {
+            m_testTimer.start();
+            StreamingReporterBase::testCaseStarting( testInfo );
+            stream << "##teamcity[testStarted name='"
+                << escape( testInfo.name ) << "']\n";
+            stream.flush();
+        }
+
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            if( !testCaseStats.stdOut.empty() )
+                stream << "##teamcity[testStdOut name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
+            if( !testCaseStats.stdErr.empty() )
+                stream << "##teamcity[testStdErr name='"
+                    << escape( testCaseStats.testInfo.name )
+                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
+            stream << "##teamcity[testFinished name='"
+                    << escape( testCaseStats.testInfo.name ) << "' duration='"
+                    << m_testTimer.getElapsedMilliseconds() << "']\n";
+            stream.flush();
+        }
+
+    private:
+        void printSectionHeader( std::ostream& os ) {
+            assert( !m_sectionStack.empty() );
+
+            if( m_sectionStack.size() > 1 ) {
+                os << getLineOfChars<'-'>() << "\n";
+
+                std::vector<SectionInfo>::const_iterator
+                it = m_sectionStack.begin()+1, // Skip first section (test case)
+                itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( os, it->name );
+                os << getLineOfChars<'-'>() << "\n";
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            os << lineInfo << "\n";
+            os << getLineOfChars<'.'>() << "\n\n";
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            os << Column( _string )
+                           .indent( indent+i)
+                           .initialIndent( indent ) << "\n";
+        }
+    private:
+        bool m_headerPrintedForThisSection = false;
+        Timer m_testTimer;
+    };
+
+#ifdef CATCH_IMPL
+    TeamCityReporter::~TeamCityReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
+
+} // end namespace Catch
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

thermal/ThermalComponent.cpp

@@ -40,11 +40,11 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
 	}
 }
 
-ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, ssize_t size) {
+ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
 	if (size != 4 * sizeof(parameters.lowerOpLimit)) {
 		return MonitoringIF::INVALID_SIZE;
 	}
-	ssize_t readSize = size;
+	size_t readSize = size;
 	SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
 			&readSize, true);
 	SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,

thermal/ThermalComponent.h

@@ -53,7 +53,7 @@ public:
 
 	ReturnValue_t setTargetState(int8_t newState);
 
-	virtual ReturnValue_t setLimits( const uint8_t* data, ssize_t size);
+	virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
 
 	virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
 				ParameterWrapper *parameterWrapper,

timemanager/Stopwatch.cpp

@@ -12,7 +12,7 @@ Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayMode(displayMode),
         displayOnDestruction(displayOnDestruction) {
     // Measures start time on initialization.
-    Clock::getUptime(&startTime);
+    startTime = Clock::getUptime();
 }
 
 void Stopwatch::start() {
@@ -31,8 +31,8 @@ seconds_t Stopwatch::stopSeconds() {
 
 void Stopwatch::display() {
     if(displayMode == StopwatchDisplayMode::MILLIS) {
-        info << "Stopwatch: Operation took " << elapsedTime.tv_sec * 1000 +
-                elapsedTime.tv_usec * 1000 << " milliseconds" << std::endl;
+        info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 +
+                elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl;
     }
     else if(displayMode == StopwatchDisplayMode::SECONDS) {
         info <<"Stopwatch: Operation took "  << std::setprecision(3)

tmstorage/TmStorePackets.h

@@ -48,7 +48,7 @@ public:
 		return sizeof(apid) + sizeof(ssc);
 	}
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
 				buffer, size, bigEndian);
@@ -257,7 +257,7 @@ public:
 
 	};
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 	bool bigEndian) {
 		ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
 				size, bigEndian);

tmtcpacket/packetmatcher/ApidMatcher.h

@@ -30,9 +30,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
+		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer,
+				size, bigEndian);
 	}
 };
 

tmtcpacket/packetmatcher/ServiceMatcher.h

@@ -30,9 +30,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
+		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer,
+				size, bigEndian);
 	}
 };
 

tmtcpacket/packetmatcher/SubserviceMatcher.h

@@ -28,9 +28,10 @@ public:
 	size_t getSerializedSize() const {
 		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
 	}
-	ReturnValue_t deSerialize(const uint8_t** buffer, ssize_t* size,
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
 			bool bigEndian) {
-		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
+		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer,
+				size, bigEndian);
 	}
 private:
 	uint8_t subService;

tmtcpacket/pus/TcPacketBase.cpp

@@ -28,7 +28,7 @@ const uint8_t* TcPacketBase::getApplicationData() const {
 	return &tcData->data;
 }
 
-uint16_t TcPacketBase::getApplicationDataSize() {
+size_t TcPacketBase::getApplicationDataSize() {
 	return getPacketDataLength() - sizeof(tcData->data_field) - CRC_SIZE + 1;
 }
 

tmtcpacket/pus/TcPacketBase.h

@@ -151,7 +151,7 @@ public:
 	 * @return	The size of the PUS Application Data (without Error Control
 	 * 		field)
 	 */
-	uint16_t getApplicationDataSize();
+	size_t getApplicationDataSize();
 	/**
 	 * This getter returns the Error Control Field of the packet.
 	 *

tmtcservices/TmTcBridge.cpp

@@ -104,7 +104,7 @@ ReturnValue_t TmTcBridge::readTmQueue() {
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
 	info << "TMTC Bridge: Comm Link down. "
-			"Saving packet ID to be sent later " << std::endl;
+			"Saving packet ID to be sent later\r\n" << std::flush;
 	store_address_t storeId;
 
 	if(fifo.full()) {
@@ -124,7 +124,7 @@ ReturnValue_t TmTcBridge::sendStoredTm() {
 	ReturnValue_t result = RETURN_OK;
 	while(!fifo.empty() && counter < MAX_STORED_DATA_SENT_PER_CYCLE) {
 		info << "UDP Server: Sending stored TM data. There are "
-				<< (int) fifo.size() << " left to send" << std::endl;
+				<< (int) fifo.size() << " left to send\r\n" << std::flush;
 		store_address_t storeId;
 		const uint8_t* data = NULL;
 		size_t size = 0;