fixed vector test

datapool/PoolEntry.cpp

@@ -6,27 +6,19 @@
 #include <algorithm>
 
 template <typename T>
-PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, uint8_t setLength,
+PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid ):
-		bool setValid ) : length(setLength), valid(setValid) {
+		length(initValue.size()), valid(setValid) {
 	this->address = new T[this->length];
 	if(initValue.size() == 0) {
 		std::memset(this->address, 0, this->getByteSize());
 	}
-	else if (initValue.size() != setLength){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "PoolEntry: setLength is not equal to initializer list"
-				"length! Performing zero initialization with given setLength"
-				<< std::endl;
-#endif
-		std::memset(this->address, 0, this->getByteSize());
-	}
 	else {
 		std::copy(initValue.begin(), initValue.end(), this->address);
 	}
 }
 
 template <typename T>
-PoolEntry<T>::PoolEntry( T* initValue, uint8_t setLength, bool setValid ) :
+PoolEntry<T>::PoolEntry(T* initValue, uint8_t setLength, bool setValid):
 		length(setLength), valid(setValid) {
 	this->address = new T[this->length];
 	if (initValue != nullptr) {

datapool/PoolEntry.h

@@ -43,16 +43,16 @@ public:
 	 * corresponding length should be passed too, otherwise a zero
 	 * initialization will be performed with the given setLength.
 	 * @param initValue
-	 * Initializer list with values to initialize with, for example {0,0} to
+	 * Initializer list with values to initialize with, for example {0, 0} to
-	 * initialize the two entries to zero.
+	 * initialize the a pool entry of a vector with two entries to 0.
 	 * @param setLength
 	 * Defines the array length of this entry. Should be equal to the
 	 * intializer list length.
 	 * @param setValid
 	 * Sets the initialization flag. It is invalid by default.
 	 */
-	PoolEntry(std::initializer_list<T> initValue = {}, uint8_t setLength = 1,
+	PoolEntry(std::initializer_list<T> initValue = {0}, bool setValid = false);
-			bool setValid = false);
+
 	/**
 	 * @brief	In the classe's constructor, space is allocated on the heap and
 	 * 			potential init values are copied to that space.

datapoollocal/LocalPoolVector.h

@@ -139,6 +139,14 @@ public:
 			MutexIF::TimeoutType::WAITING,
 			uint32_t timeoutMs = 20) override;
 
+	/**
+	 * @brief	This commit call also sets the validity of the pool entry.
+	 * @details
+	 */
+	ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::WAITING,
+			uint32_t timeoutMs = 20);
+
 protected:
 	/**
 	 * @brief	Like #read, but without a lock protection of the global pool.

datapoollocal/LocalPoolVector.tpp

@@ -54,6 +54,13 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
 	return RETURN_OK;
 }
 
+template<typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
+		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+	this->setValid(valid);
+	return commit(timeoutType, timeoutMs);
+}
+
 template<typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
 		MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {

osal/host/Mutex.h

@@ -22,7 +22,6 @@ public:
 
 	std::timed_mutex* getMutexHandle();
 private:
-	//bool locked = false;
 	std::timed_mutex mutex;
 };
 

unittest/tests/datapoollocal/CMakeLists.txt

@@ -1,3 +1,4 @@
 target_sources(${TARGET_NAME} PRIVATE
 	LocalPoolVariableTest.cpp
+	LocalPoolVectorTest.cpp
 )

unittest/tests/datapoollocal/LocalPoolVectorTest.cpp

@@ -11,6 +11,28 @@ TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
 	REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
 	REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation()
 			== retval::CATCH_OK);
+
+	SECTION("BasicTest") {
+		// very basic test.
+		lp_vec_t<uint16_t, 3> testVector = lp_vec_t<uint16_t, 3>(
+				objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+		CHECK(testVector.read() == retval::CATCH_OK);
+		testVector.value[0] = 5;
+		testVector.value[1] = 232;
+		testVector.value[2] = 32023;
+
+		REQUIRE(testVector.commit(true) == retval::CATCH_OK);
+		CHECK(testVector.isValid());
+
+		testVector.value[0] = 0;
+		testVector.value[1] = 0;
+		testVector.value[2] = 0;
+
+		CHECK(testVector.read() == retval::CATCH_OK);
+		CHECK(testVector.value[0] == 5);
+		CHECK(testVector.value[1] == 232);
+		CHECK(testVector.value[2] == 32023);
+	}
 }