Merge with pip 3

tests/CMakeLists.txt

@@ -0,0 +1,18 @@
+include(DownloadGTest)
+
+macro(pip_test NAME LIBS)
+	file(GLOB _CPPS "${NAME}/*.cpp")
+	file(GLOB _HDRS "${NAME}/*.h")
+	set(_target pip_${NAME}_test)
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PIP_ROOT_BINARY_DIR}")
+	add_executable(${_target} ${_CPPS} ${_HDRS})
+	target_link_libraries(${_target} pip ${LIBS} gtest_main gmock_main)
+	add_test(NAME ${_target} COMMAND tests)
+	add_custom_target(${_target}_perform ALL COMMAND ${_target})
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+	list(APPEND PIP_TESTS_LIST "${NAME}")
+	set(PIP_TESTS_LIST ${PIP_TESTS_LIST} PARENT_SCOPE)
+endmacro()
+
+# Concurrent tests
+pip_test(concurrent "")

tests/GTestCMakeLists.txt.in

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 2.8.2)
+
+project(googletest-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(googletest
+  GIT_REPOSITORY    https://github.com/google/googletest.git
+  GIT_TAG           "dea0216d0c6bc5e63cf5f6c8651cd268668032ec"
+  GIT_CONFIG        "advice.detachedHead=false"
+  SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
+  BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND     ""
+  INSTALL_COMMAND   ""
+  TEST_COMMAND      ""
+)

tests/concurrent/BlockingDequeueUnitTest.cpp

@@ -0,0 +1,264 @@
+#include "gtest/gtest.h"
+#include "piblockingqueue.h"
+
+class MockConditionVar: public PIConditionVariable {
+public:
+    bool isWaitCalled = false;
+    bool isWaitForCalled = false;
+    bool isTrueCondition = false;
+    int timeout = -1;
+
+	void wait(PIMutex& lk) override {
+        isWaitCalled = true;
+    }
+
+	void wait(PIMutex& lk, const std::function<bool()>& condition) override {
+        isWaitCalled = true;
+        lk.lock();
+        isTrueCondition = condition();
+        lk.unlock();
+    }
+
+	bool waitFor(PIMutex& lk, int timeoutMs) override {
+        isWaitForCalled = true;
+        timeout = timeoutMs;
+        return false;
+    }
+
+	bool waitFor(PIMutex& lk, int timeoutMs, const std::function<bool()>& condition) override {
+        isWaitForCalled = true;
+        lk.lock();
+        isTrueCondition = condition();
+        timeout = timeoutMs;
+        lk.unlock();
+        return isTrueCondition;
+    }
+};
+
+TEST(BlockingDequeueUnitTest, put_is_block_when_capacity_reach) {
+    size_t capacity = 0;
+    auto conditionVarAdd = new MockConditionVar();
+    auto conditionVarRem = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVarAdd, conditionVarRem);
+    dequeue.put(11);
+    ASSERT_TRUE(conditionVarRem->isWaitCalled);
+    ASSERT_FALSE(conditionVarRem->isTrueCondition);
+}
+
+TEST(BlockingDequeueUnitTest, offer_timedout_is_false_when_capacity_reach) {
+    size_t capacity = 0;
+    int timeout = 11;
+    auto conditionVarAdd = new MockConditionVar();
+    auto conditionVarRem = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVarAdd, conditionVarRem);
+    ASSERT_FALSE(dequeue.offer(11, timeout));
+}
+
+TEST(BlockingDequeueUnitTest, offer_timedout_is_block_when_capacity_reach) {
+    size_t capacity = 0;
+    int timeout = 11;
+    auto conditionVarAdd = new MockConditionVar();
+    auto conditionVarRem = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVarAdd, conditionVarRem);
+    dequeue.offer(11, timeout);
+    EXPECT_TRUE(conditionVarRem->isWaitForCalled);
+    EXPECT_EQ(timeout, conditionVarRem->timeout);
+    ASSERT_FALSE(conditionVarRem->isTrueCondition);
+}
+
+TEST(BlockingDequeueUnitTest, offer_is_true_before_capacity_reach) {
+    size_t capacity = 1;
+	PIBlockingQueue<int> dequeue(capacity);
+	ASSERT_TRUE(dequeue.offer(10));
+}
+
+TEST(BlockingDequeueUnitTest, offer_is_false_when_capacity_reach) {
+    size_t capacity = 1;
+	PIBlockingQueue<int> dequeue(capacity);
+    dequeue.offer(11);
+    ASSERT_FALSE(dequeue.offer(10));
+}
+
+// TODO change take_is_block_when_empty to prevent segfault
+TEST(DISABLED_BlockingDequeueUnitTest, take_is_block_when_empty) {
+    size_t capacity = 1;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+    // May cause segfault because take front of empty queue
+    dequeue.take();
+    EXPECT_TRUE(conditionVar->isWaitCalled);
+    ASSERT_FALSE(conditionVar->isTrueCondition);
+}
+
+TEST(BlockingDequeueUnitTest, take_is_not_block_when_not_empty) {
+    size_t capacity = 1;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+    dequeue.offer(111);
+    dequeue.take();
+
+    EXPECT_TRUE(conditionVar->isWaitCalled);
+    ASSERT_TRUE(conditionVar->isTrueCondition);
+}
+
+TEST(BlockingDequeueUnitTest, take_is_value_eq_to_offer_value) {
+    size_t capacity = 1;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+
+    dequeue.offer(111);
+    ASSERT_EQ(dequeue.take(), 111);
+}
+
+TEST(BlockingDequeueUnitTest, take_is_last) {
+    size_t capacity = 10;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+    EXPECT_TRUE(dequeue.offer(111));
+    EXPECT_TRUE(dequeue.offer(222));
+    ASSERT_EQ(dequeue.take(), 111);
+    ASSERT_EQ(dequeue.take(), 222);
+}
+
+TEST(BlockingDequeueUnitTest, poll_is_not_block_when_empty) {
+	size_t capacity = 1;
+	bool isOk;
+	auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+	dequeue.poll(0, 111, &isOk);
+	EXPECT_FALSE(conditionVar->isWaitForCalled);
+}
+
+TEST(BlockingDequeueUnitTest, poll_is_default_value_when_empty) {
+	size_t capacity = 1;
+	bool isOk;
+	auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+	ASSERT_EQ(dequeue.poll(0, 111, &isOk), 111);
+}
+
+TEST(BlockingDequeueUnitTest, poll_is_offer_value_when_not_empty) {
+	size_t capacity = 1;
+	bool isOk;
+	auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+	dequeue.offer(111);
+	ASSERT_EQ(dequeue.poll(0, -1, &isOk), 111);
+}
+
+TEST(BlockingDequeueUnitTest, poll_timeouted_is_block_when_empty) {
+    size_t capacity = 1;
+    int timeout = 11;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+    dequeue.poll(timeout, 111);
+	EXPECT_TRUE(conditionVar->isWaitForCalled);
+	EXPECT_EQ(timeout, conditionVar->timeout);
+    ASSERT_FALSE(conditionVar->isTrueCondition);
+}
+
+TEST(BlockingDequeueUnitTest, poll_timeouted_is_default_value_when_empty) {
+    size_t capacity = 1;
+    int timeout = 11;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+    ASSERT_EQ(dequeue.poll(timeout, 111), 111);
+}
+
+TEST(BlockingDequeueUnitTest, poll_timeouted_is_not_block_when_not_empty) {
+    size_t capacity = 1;
+    int timeout = 11;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+    dequeue.offer(111);
+    dequeue.poll(timeout, -1);
+
+    EXPECT_TRUE(conditionVar->isWaitForCalled);
+    ASSERT_TRUE(conditionVar->isTrueCondition);
+}
+
+TEST(BlockingDequeueUnitTest, poll_timeouted_is_offer_value_when_not_empty) {
+    size_t capacity = 1;
+    int timeout = 11;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+    dequeue.offer(111);
+    ASSERT_EQ(dequeue.poll(timeout, -1), 111);
+}
+
+TEST(BlockingDequeueUnitTest, poll_timeouted_is_last) {
+    size_t capacity = 10;
+    auto conditionVar = new MockConditionVar();
+	PIBlockingQueue<int> dequeue(capacity, conditionVar);
+    dequeue.offer(111);
+    dequeue.offer(222);
+    ASSERT_EQ(dequeue.poll(10, -1), 111);
+    ASSERT_EQ(dequeue.poll(10, -1), 222);
+}
+
+TEST(BlockingDequeueUnitTest, capacity_is_eq_constructor_capacity) {
+    size_t capacity = 10;
+	PIBlockingQueue<int> dequeue(capacity);
+    ASSERT_EQ(dequeue.capacity(), capacity);
+}
+
+TEST(BlockingDequeueUnitTest, remainingCapacity_is_dif_of_capacity_and_size) {
+    size_t capacity = 2;
+	PIBlockingQueue<int> dequeue(capacity);
+    ASSERT_EQ(dequeue.remainingCapacity(), capacity);
+    dequeue.offer(111);
+    ASSERT_EQ(dequeue.remainingCapacity(), capacity - 1);
+}
+
+TEST(BlockingDequeueUnitTest, remainingCapacity_is_zero_when_capacity_reach) {
+    size_t capacity = 1;
+	PIBlockingQueue<int> dequeue(capacity);
+    dequeue.offer(111);
+    dequeue.offer(111);
+    ASSERT_EQ(dequeue.remainingCapacity(), 0);
+}
+
+TEST(BlockingDequeueUnitTest, size_is_eq_to_num_of_elements) {
+    size_t capacity = 1;
+	PIBlockingQueue<int> dequeue(capacity);
+    ASSERT_EQ(dequeue.size(), 0);
+    dequeue.offer(111);
+    ASSERT_EQ(dequeue.size(), 1);
+}
+
+TEST(BlockingDequeueUnitTest, size_is_eq_to_capacity_when_capacity_reach) {
+    size_t capacity = 1;
+	PIBlockingQueue<int> dequeue(capacity);
+    dequeue.offer(111);
+    dequeue.offer(111);
+    ASSERT_EQ(dequeue.size(), capacity);
+}
+
+TEST(BlockingDequeueUnitTest, drainTo_is_elements_moved) {
+    size_t capacity = 10;
+    PIDeque<int> refDeque;
+    for (size_t i = 0; i < capacity / 2; ++i) refDeque.push_back(i * 10);
+	PIBlockingQueue<int> blockingDequeue(refDeque);
+    PIDeque<int> deque;
+    blockingDequeue.drainTo(deque);
+    ASSERT_EQ(blockingDequeue.size(), 0);
+    ASSERT_TRUE(deque == refDeque);
+}
+
+TEST(BlockingDequeueUnitTest, drainTo_is_ret_eq_to_size_when_all_moved) {
+    size_t capacity = 10;
+    PIDeque<int> refDeque;
+    for (size_t i = 0; i < capacity / 2; ++i) refDeque.push_back(i * 10);
+	PIBlockingQueue<int> blockingDequeue(refDeque);
+    PIDeque<int> deque;
+    ASSERT_EQ(blockingDequeue.drainTo(deque), refDeque.size());
+}
+
+TEST(BlockingDequeueUnitTest, drainTo_is_ret_eq_to_maxCount) {
+    size_t capacity = 10;
+    PIDeque<int> refDeque;
+    for (size_t i = 0; i < capacity / 2; ++i) refDeque.push_back(i * 10);
+	PIBlockingQueue<int> blockingDequeue(refDeque);
+    PIDeque<int> deque;
+    ASSERT_EQ(blockingDequeue.drainTo(deque, refDeque.size() - 1), refDeque.size() - 1);
+}

tests/concurrent/ConditionLockIntegrationTest.cpp

@@ -0,0 +1,53 @@
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "piconditionvar.h"
+#include "pithread.h"
+#include "testutil.h"
+
+class ConditionLock : public ::testing::Test, public TestUtil {
+public:
+	PIMutex* m = new PIMutex();
+};
+
+TEST_F(ConditionLock, lock_is_protect) {
+    m->lock();
+    bool* isProtect = new bool(true);
+
+    createThread([&](){
+        m->lock();
+        *isProtect = false;
+    });
+	EXPECT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
+    ASSERT_TRUE(*isProtect);
+}
+
+TEST_F(ConditionLock, unlock_is_release) {
+    m->lock();
+    bool* isReleased = new bool(false);
+    m->unlock();
+
+    createThread([&](){
+        m->lock();
+        *isReleased = true;
+        m->unlock();
+    });
+    ASSERT_TRUE(*isReleased);
+}
+
+TEST_F(ConditionLock, tryLock_is_false_when_locked) {
+    createThread([&](){
+        m->lock();
+        piMSleep(WAIT_THREAD_TIME_MS);
+    });
+    ASSERT_FALSE(m->tryLock());
+}
+
+TEST_F(ConditionLock, tryLock_is_true_when_unlocked) {
+    ASSERT_TRUE(m->tryLock());
+}
+
+TEST_F(ConditionLock, tryLock_is_recursive_lock_enable) {
+    m->lock();
+    ASSERT_TRUE(m->tryLock());
+}

tests/concurrent/ConditionVariableIntegrationTest.cpp

@@ -0,0 +1,200 @@
+#include "gtest/gtest.h"
+#include "piconditionvar.h"
+#include "pithread.h"
+#include "testutil.h"
+
+class ConditionVariable : public ::testing::Test, public TestUtil {
+public:
+	PIMutex m;
+    PIConditionVariable* variable;
+
+protected:
+    void SetUp() override {
+        variable = new PIConditionVariable();
+        adapterFunctionDefault = [&](){
+            m.lock();
+            variable->wait(m);
+            m.unlock();
+        };
+    }
+};
+
+TEST_F(ConditionVariable, wait_is_block) {
+    createThread();
+    ASSERT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
+}
+
+TEST_F(ConditionVariable, wait_is_block_when_notifyOne_before_wait) {
+    variable->notifyOne();
+    createThread();
+    ASSERT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
+}
+
+TEST_F(ConditionVariable, wait_is_block_when_notifyAll_before_wait) {
+    variable->notifyAll();
+    createThread();
+    ASSERT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
+}
+
+TEST_F(ConditionVariable, wait_is_unblock_when_notifyOne_after_wait) {
+    createThread();
+    variable->notifyOne();
+    ASSERT_TRUE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
+}
+
+TEST_F(ConditionVariable, wait_is_unblock_when_notifyAll_after_wait) {
+    PIVector<PIThread*> threads;
+
+    for (int i = 0; i < THREAD_COUNT; ++i) {
+        threads.push_back(new PIThread([=](){ adapterFunctionDefault(); }));
+    }
+
+    piForeach(PIThread* thread, threads) thread->startOnce();
+    piMSleep(WAIT_THREAD_TIME_MS * THREAD_COUNT);
+    variable->notifyAll();
+    PITimeMeasurer measurer;
+    piForeach(PIThread* thread, threads) {
+        int timeout = WAIT_THREAD_TIME_MS * THREAD_COUNT - (int)measurer.elapsed_m();
+        thread->waitForFinish(timeout > 0 ? timeout : 0);
+    }
+    for (size_t i = 0; i < threads.size(); ++i) EXPECT_FALSE(threads[i]->isRunning()) << "Thread " << i << " still running";
+    piForeach(PIThread* thread, threads) delete thread;
+}
+
+TEST_F(ConditionVariable, wait_is_one_unblock_when_notifyOne) {
+    PIVector<PIThread*> threads;
+
+    for (int i = 0; i < THREAD_COUNT; ++i) {
+        threads.push_back(new PIThread(adapterFunctionDefault));
+    }
+
+    piForeach(PIThread* thread, threads) thread->startOnce();
+    piMSleep(WAIT_THREAD_TIME_MS * THREAD_COUNT);
+    variable->notifyOne();
+    piMSleep(WAIT_THREAD_TIME_MS * THREAD_COUNT);
+    int runningThreadCount = 0;
+    piForeach(PIThread* thread, threads) if (thread->isRunning()) runningThreadCount++;
+    ASSERT_EQ(runningThreadCount, THREAD_COUNT - 1);
+}
+
+TEST_F(ConditionVariable, wait_is_protected_unblock_when_notifyOne) {
+    createThread([&](){
+        m.lock();
+        variable->wait(m);
+        piMSleep(2 * WAIT_THREAD_TIME_MS);
+        // Missing unlock
+    });
+    variable->notifyOne();
+    msleep(WAIT_THREAD_TIME_MS);
+    ASSERT_FALSE(m.tryLock());
+}
+
+TEST_F(ConditionVariable, wait_condition_is_block) {
+    createThread([&](){
+        m.lock();
+        variable->wait(m, [](){ return false; });
+        m.unlock();
+    });
+    ASSERT_FALSE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
+}
+
+TEST_F(ConditionVariable, wait_condition_is_check_condition_before_block) {
+    bool isConditionChecked = false;
+    createThread([&](){
+        m.lock();
+        variable->wait(m, [&](){
+            isConditionChecked = true;
+            return false;
+        });
+        m.unlock();
+    });
+    m.lock();
+    ASSERT_TRUE(isConditionChecked);
+    m.unlock();
+}
+
+TEST_F(ConditionVariable, wait_condition_is_check_condition_when_notifyOne) {
+    bool isConditionChecked;
+    createThread([&](){
+        m.lock();
+        variable->wait(m, [&](){
+            isConditionChecked = true;
+            return false;
+        });
+        m.unlock();
+    });
+    m.lock();
+    isConditionChecked = false;
+    m.unlock();
+    variable->notifyOne();
+    msleep(threadStartTime + 1);
+    m.lock();
+    ASSERT_TRUE(isConditionChecked);
+    m.unlock();
+}
+
+TEST_F(ConditionVariable, wait_condition_is_unblock_when_condition_and_notifyOne) {
+    bool condition = false;
+    createThread([&](){
+        m.lock();
+        variable->wait(m, [&](){ return condition; });
+        m.unlock();
+    });
+    m.lock();
+    condition = true;
+    m.unlock();
+    variable->notifyOne();
+    ASSERT_TRUE(thread->waitForFinish(WAIT_THREAD_TIME_MS));
+}
+
+TEST_F(ConditionVariable, DISABLED_waitFor_is_block_before_timeout) {
+    createThread([&](){
+        PITimeMeasurer measurer;
+        m.lock();
+        variable->waitFor(m, WAIT_THREAD_TIME_MS * 2);
+        m.unlock();
+        // Not reliable because spurious wakeup may happen
+        ASSERT_GE(measurer.elapsed_m(), WAIT_THREAD_TIME_MS);
+    });
+    EXPECT_TRUE(thread->waitForFinish(WAIT_THREAD_TIME_MS * 3));
+}
+
+TEST_F(ConditionVariable, waitFor_is_unblock_when_timeout) {
+    std::atomic_bool isUnblock(false);
+    createThread([&](){
+        m.lock();
+        variable->waitFor(m, WAIT_THREAD_TIME_MS);
+        isUnblock = true;
+        m.unlock();
+    });
+    // Test failed if suspend forever
+    EXPECT_TRUE(thread->waitForFinish(2 * WAIT_THREAD_TIME_MS));
+    ASSERT_TRUE(isUnblock);
+}
+
+TEST_F(ConditionVariable, waitFor_is_false_when_timeout) {
+    bool waitRet = true;
+    createThread([&](){
+        m.lock();
+        waitRet = variable->waitFor(m, WAIT_THREAD_TIME_MS);
+        m.unlock();
+    });
+    EXPECT_TRUE(thread->waitForFinish(2 * WAIT_THREAD_TIME_MS));
+    ASSERT_FALSE(waitRet);
+}
+
+TEST_F(ConditionVariable, waitFor_is_unblock_when_condition_and_notifyOne) {
+    bool condition = false;
+    createThread([&](){
+        m.lock();
+        variable->waitFor(m, 3 * WAIT_THREAD_TIME_MS, [&](){ return condition; });
+        m.unlock();
+    });
+    EXPECT_TRUE(thread->isRunning());
+    m.lock();
+    condition = true;
+    m.unlock();
+    variable->notifyOne();
+    msleep(WAIT_THREAD_TIME_MS);
+    ASSERT_FALSE(thread->isRunning());
+}

tests/concurrent/ExecutorIntegrationTest.cpp

@@ -0,0 +1,54 @@
+#include "gtest/gtest.h"
+#include "pithreadpoolexecutor.h"
+#include "pimutex.h"
+
+const int WAIT_THREAD_TIME_MS = 30;
+
+TEST(ExcutorIntegrationTest, execute_is_runnable_invoke) {
+    PIMutex m;
+    int invokedRunnables = 0;
+    PIThreadPoolExecutor executorService(1);
+    executorService.execute([&]() {
+        m.lock();
+        invokedRunnables++;
+        m.unlock();
+    });
+    piMSleep(WAIT_THREAD_TIME_MS);
+    ASSERT_EQ(invokedRunnables, 1);
+}
+
+TEST(ExcutorIntegrationTest, execute_is_not_execute_after_shutdown) {
+    bool isRunnableInvoke = false;
+    PIThreadPoolExecutor executorService(1);
+    executorService.shutdown();
+    executorService.execute([&]() {
+        isRunnableInvoke = true;
+    });
+    piMSleep(WAIT_THREAD_TIME_MS);
+    ASSERT_FALSE(isRunnableInvoke);
+}
+
+TEST(ExcutorIntegrationTest, execute_is_execute_before_shutdown) {
+    bool isRunnableInvoke = false;
+    PIThreadPoolExecutor executorService(1);
+    executorService.execute([&]() {
+        piMSleep(WAIT_THREAD_TIME_MS);
+        isRunnableInvoke = true;
+    });
+    executorService.shutdown();
+    piMSleep(2 * WAIT_THREAD_TIME_MS);
+    ASSERT_TRUE(isRunnableInvoke);
+}
+
+TEST(ExcutorIntegrationTest, execute_is_awaitTermination_wait) {
+    PIThreadPoolExecutor executorService(1);
+    executorService.execute([&]() {
+        piMSleep(2 * WAIT_THREAD_TIME_MS);
+    });
+    executorService.shutdown();
+    PITimeMeasurer measurer;
+    ASSERT_TRUE(executorService.awaitTermination(3 * WAIT_THREAD_TIME_MS));
+    double waitTime = measurer.elapsed_m();
+    ASSERT_GE(waitTime, WAIT_THREAD_TIME_MS);
+    ASSERT_LE(waitTime, 4 * WAIT_THREAD_TIME_MS);
+}

tests/concurrent/testutil.h

@@ -0,0 +1,60 @@
+#ifndef AWRCANFLASHER_TESTUTIL_H
+#define AWRCANFLASHER_TESTUTIL_H
+
+#include "pithread.h"
+#include <atomic>
+
+/**
+ * Minimum wait thread start, switch context or another interthread communication action time. Increase it if tests
+ * write "Start thread timeout reach!" message. You can reduce it if you want increase test performance.
+ */
+const int WAIT_THREAD_TIME_MS = 40;
+
+const int THREAD_COUNT = 5;
+
+class TestUtil: public PIObject {
+PIOBJECT(TestUtil)
+public:
+    double threadStartTime;
+    PIThread* thread = new PIThread();
+    std::atomic_bool isRunning;
+    std::function<void()> adapterFunctionDefault;
+
+	TestUtil() : isRunning(false) {}
+
+	bool createThread(const std::function<void()>&  fun = nullptr, PIThread* thread_ = nullptr) {
+    	std::function<void()> actualFun = fun == nullptr ? adapterFunctionDefault : fun;
+        if (thread_ == nullptr) thread_ = thread;
+        thread_->startOnce([=](void*){
+			isRunning = true;
+        	actualFun();
+        });
+        return waitThread(thread_);
+    }
+
+    bool waitThread(PIThread* thread_, bool runningStatus = true) {
+        PITimeMeasurer measurer;
+        bool isTimeout = !thread_->waitForStart(WAIT_THREAD_TIME_MS);
+        while (!isRunning) {
+            isTimeout = WAIT_THREAD_TIME_MS <= measurer.elapsed_m();
+            if (isTimeout) break;
+            piUSleep(100);
+        }
+
+        threadStartTime = measurer.elapsed_m();
+
+        if (isTimeout) piCout << "Start thread timeout reach!";
+
+        if (threadStartTime > 1) {
+            piCout << "Start time" << threadStartTime << "ms";
+        } else if (threadStartTime > 0.001) {
+            piCout << "Start time" << threadStartTime * 1000 << "mcs";
+        } else {
+            piCout << "Start time" << threadStartTime * 1000 * 1000 << "ns";
+        }
+
+        return !isTimeout;
+    }
+};
+
+#endif //AWRCANFLASHER_TESTUTIL_H

tests/math/testpimathmatrix.cpp

@@ -0,0 +1,763 @@
+#include "gtest/gtest.h"
+#include "pimathmatrix.h"
+
+bool cmpMatrixWithValue(PIMathMatrix<double> matrix, double val)
+{
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    bool b;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix.element(j,k) == val)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    return b;
+}
+
+TEST(PIMathMatrix_Test, identity)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix;
+    int i;
+    bool b;
+    matrix = origMatr.identity(3, 3);
+    for(i = 0; i < 3; i++)
+    {
+        if(matrix[i][i] == 1.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, matrixRow)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    uint i;
+    bool b;
+    vector.resize(3, 3.0);
+    vector.fill(5.0);
+    matrix = origMatr.matrixRow(vector);
+    for(i = 0; i < vector.size(); i++)
+    {
+        if(matrix[0][i] == 5.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, matrixCol)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    uint i;
+    bool b;
+    vector.resize(3, 3.0);
+    vector.fill(5.0);
+    matrix = origMatr.matrixCol(vector);
+    for(i = 0; i < vector.size(); i++)
+    {
+        if(matrix[i][0] == 5.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, setCol)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    uint i;
+    bool b;
+    vector.resize(3, 3.0);
+    vector.fill(5.0);
+    matrix = origMatr.matrixCol(vector);
+    vector.fill(10.0);
+    matrix.setCol(0, vector);
+    for(i = 0; i < vector.size(); i++)
+    {
+        if(matrix[i][0] == 10.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, setRow)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    uint i;
+    bool b;
+    vector.resize(3, 3.0);
+    vector.fill(5.0);
+    matrix = origMatr.matrixRow(vector);
+    vector.fill(10.0);
+    matrix.setRow(0, vector);
+    for(i = 0; i < vector.size(); i++)
+    {
+        if(matrix[0][i] == 10.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, swapCols)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathVector<double> vector;
+    uint i1 = 0; uint i2 = 1;
+    double a1[3], a2[3], a3[3];
+    double b1[3], b2[3], b3[3];
+    bool b;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    for(int i = 0; i < 3; i++)
+    {
+        a1[i] = matrix1.element(i, 0);
+        a2[i] = matrix1.element(i, 1);
+        a3[i] = matrix1.element(i, 2);
+    }
+    matrix1.swapCols(i1, i2);
+    for(int i = 0; i < 3; i++)
+    {
+        b1[i] = matrix1.element(i, 0);
+        b2[i] = matrix1.element(i, 1);
+        b3[i] = matrix1.element(i, 2);
+    }
+    if((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, swapRows)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathVector<double> vector;
+    uint i1 = 0; uint i2 = 1;
+    double a1[3], a2[3], a3[3];
+    double b1[3], b2[3], b3[3];
+    bool b;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    for(int i = 0; i < 3; i++)
+    {
+        a1[i] = matrix1.element(0, i);
+        a2[i] = matrix1.element(1, i);
+        a3[i] = matrix1.element(2, i);
+    }
+    matrix1.swapRows(i1, i2);
+    for(int i = 0; i < 3; i++)
+    {
+        b1[i] = matrix1.element(0, i);
+        b2[i] = matrix1.element(1, i);
+        b3[i] = matrix1.element(2, i);
+    }
+    if((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+TEST(PIMathMatrix_Test, fill)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix;
+    bool b;
+    matrix = origMatr.identity(3, 3);
+    matrix.fill(5.0);
+    b = cmpMatrixWithValue(matrix, 5.0);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, isSquare)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(4,3);
+    if((matrix1.isSquare() == true) && (matrix2.isSquare() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, isIdentity)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix2.fill(3.932);
+    if((matrix1.isIdentity() == true) && (matrix2.isIdentity() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, isNull)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix1.fill(0.0);
+    matrix2.fill(3.932);
+    if((matrix1.isNull() == true) && (matrix2.isNull() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, isValid)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    if((matrix1.isValid() == true) && (matrix2.isValid() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Assignment)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix2.fill(6.72);
+    matrix1 = matrix2;
+    b = cmpMatrixWithValue(matrix1, 6.72);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Equal)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathVector<double> vector;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix3 = origMatr.identity(3,3);
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1.setCol(0, vector);
+    matrix2.setCol(0, vector);
+    matrix3.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    matrix2.setCol(1, vector);
+    matrix3.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    matrix2.setCol(2, vector);
+    vector.at(0) = 566.0;
+    vector.at(1) = 564.0;
+    vector.at(2) = 543.0;
+    matrix3.setCol(2, vector);
+    if(((matrix1 == matrix2) == true) && ((matrix1 == matrix3) == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Not_Equal)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathVector<double> vector;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix3 = origMatr.identity(3,3);
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1.setCol(0, vector);
+    matrix2.setCol(0, vector);
+    matrix3.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    matrix2.setCol(1, vector);
+    matrix3.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    matrix2.setCol(2, vector);
+    vector.at(0) = 566.0;
+    vector.at(1) = 564.0;
+    vector.at(2) = 543.0;
+    matrix3.setCol(2, vector);
+    if(((matrix1 != matrix2) == false) && ((matrix1 != matrix3) == true))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Addition_Aassignment)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix2.fill(6.72);
+    matrix1.fill(1.0);
+    matrix1 += matrix2;
+    b = cmpMatrixWithValue(matrix1, 7.72);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Subtraction_Assignment)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix2.fill(6.72);
+    matrix1.fill(1.0);
+    matrix1 -= matrix2;
+    b = cmpMatrixWithValue(matrix1, -5.72);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Multiplication_Assignment)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix1 *= 2.0;
+    b = cmpMatrixWithValue(matrix1, 13.44);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Division_Assignment)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix1 /= 2.0;
+    b = cmpMatrixWithValue(matrix1, 3.36);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Addition)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix2.fill(8.28);
+    b = cmpMatrixWithValue(matrix1 + matrix2, 15.0);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Subtraction)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3, 3);
+    matrix2 = origMatr.identity(3, 3);
+    origMatr.fill(8.0);
+    matrix1.fill(8.28);
+    origMatr = origMatr - matrix1;
+    matrix2.fill(-0.28);
+    if(origMatr == matrix2)
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, operator_Multiplication)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix2 = matrix1*4.0;
+    b = cmpMatrixWithValue(matrix2, 26.88);
+    ASSERT_TRUE(b);
+}
+TEST(PIMathMatrix_Test, operator_Division)
+{
+    PIMathMatrix<double> origMatr;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    bool b;
+    matrix1 = origMatr.identity(3,3);
+    matrix2 = origMatr.identity(3,3);
+    matrix1.fill(6.72);
+    matrix2 = matrix1/4.0;
+    b = cmpMatrixWithValue(matrix2, 1.68);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, determinant)
+{
+    PIMathMatrix<double> origMatr;
+    double d;
+    double i = 59.0;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix = origMatr.identity(3, 3);
+    matrix.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix.setCol(2, vector);
+    d = matrix.determinant();
+    ASSERT_DOUBLE_EQ(d, i);
+}
+
+TEST(PIMathMatrix_Test, trace)
+{
+    PIMathMatrix<double> origMatr;
+    double t;
+    double i = 9.0;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix = origMatr.identity(3, 3);
+    matrix.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix.setCol(2, vector);
+    t = matrix.trace();
+    ASSERT_DOUBLE_EQ(t, i);
+}
+
+TEST(PIMathMatrix_Test, toUpperTriangular)
+{
+    PIMathMatrix<double> origMatr;
+    double d1, d2 = 1;
+    int i;
+    PIMathMatrix<double> matrix;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix = origMatr.identity(3, 3);
+    matrix.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix.setCol(2, vector);
+    d1 = matrix.determinant();
+    matrix.toUpperTriangular();
+    for(i = 0; i < 3; i++)
+    {
+        d2 = d2 * matrix.element(i, i);
+    }
+    ASSERT_DOUBLE_EQ(d1, d2);
+}
+
+TEST(PIMathMatrix_Test, invert)
+{
+    PIMathMatrix<double> origMatr;
+    double d1, d2;
+    bool b;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathMatrix<double> matrix4;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    d1 = matrix1.determinant();
+    matrix2 = matrix1;
+    matrix2.invert();
+    d2 = matrix2.determinant();
+    matrix3 = origMatr.identity(3, 3);
+    matrix4 = origMatr.identity(3, 3);
+    matrix4.invert();
+    if((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, inverted)
+{
+    PIMathMatrix<double> origMatr;
+    double d1, d2;
+    bool b;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathMatrix<double> matrix4;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    d1 = matrix1.determinant();
+    matrix2 = matrix1;
+    matrix1 = matrix2.invert();
+    d2 = matrix1.determinant();
+    matrix3 = origMatr.identity(3, 3);
+    matrix4 = origMatr.identity(3, 3);
+    matrix3 = matrix4.invert();
+    if((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrix_Test, transposed)
+{
+    PIMathMatrix<double> origMatr;
+    double d1, d2;
+    bool b;
+    PIMathMatrix<double> matrix1;
+    PIMathMatrix<double> matrix2;
+    PIMathMatrix<double> matrix3;
+    PIMathVector<double> vector;
+    vector.resize(3, 3.0);
+    vector.at(0) = 3.0;
+    vector.at(1) = 6.0;
+    vector.at(2) = 8.0;
+    matrix1 = origMatr.identity(3, 3);
+    matrix1.setCol(0, vector);
+    vector.at(0) = 2.0;
+    vector.at(1) = 1.0;
+    vector.at(2) = 4.0;
+    matrix1.setCol(1, vector);
+    vector.at(0) = 6.0;
+    vector.at(1) = 2.0;
+    vector.at(2) = 5.0;
+    matrix1.setCol(2, vector);
+    d1 = matrix1.determinant();
+    matrix2 = matrix1.transposed();
+    d2 = matrix2.determinant();
+    matrix3 = matrix2.transposed();
+    if((d1 == d2) && (matrix1 == matrix3))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}

tests/math/testpimathmatrixt.cpp

@@ -0,0 +1,833 @@
+#include "gtest/gtest.h"
+#include "pimathmatrix.h"
+
+const uint rows = 3;
+const uint cols = 3;
+
+bool cmpMatrixWithValue(PIMathMatrixT<rows, cols, double> matrix, double val)
+{
+    int i = 0;
+    int j = 0;
+    int k = 0;
+    bool b;
+    while(i < 9)
+    {
+        if(k < 3)
+        {
+            if(matrix.at(j,k) == val)
+            {
+                b = true;
+            }
+            else
+            {
+                b = false;
+                break;
+            }
+            k++;
+            if(k == 3)
+            {
+                j++;
+                k = 0;
+            }
+        }
+        i++;
+    }
+    return b;
+}
+
+
+TEST(PIMathMatrixT_Test, identity)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathMatrixT<rows, cols, double> matrix;
+    double d;
+    double i = 1.0;
+    bool a;
+    bool output;
+    matrix = matr.identity();
+    d = matrix.determinant();
+    uint j;
+    for(j = 0; j < cols; j++)
+    {
+        if(matrix.at(i, i) == 1.0) a = true;
+        else
+        {
+            a = false;
+            break;
+        }
+    }
+    if((i == d) && (a == true)){
+        output = true;
+    }
+    else{
+        output = false;
+    }
+    ASSERT_TRUE(output);
+}
+
+TEST(PIMathMatrixT_Test, at)
+{
+    uint i;
+    bool b;
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    matrix1 = matr.identity();
+    matrix2 = matr.identity();
+    for(i = 0; i < rows; i++)
+    {
+        if(matrix1.at(i,i) == 1.0)
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+TEST(PIMathMatrixT_Test, filled)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathVectorT<rows, double> vect;
+    double g = 1.0;
+    matrix2 = matr.fill(g);
+    uint j = 0, i = 0;
+    for(i = 0; i < cols; i++)
+    {
+        for(j = 0; j < rows; j++)
+        {
+            matrix1.at(j,i) = g;
+        }
+    }
+    ASSERT_TRUE(matrix2 == matrix1);
+}
+
+TEST(PIMathMatrixT_Test, cols)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    ASSERT_EQ(cols,matr.cols());
+}
+
+TEST(PIMathMatrixT_Test, rows)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    ASSERT_EQ(rows,matr.rows());
+}
+
+TEST(PIMathMatrixT_Test, col)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathVectorT<rows, double> vect;
+    uint i;
+    uint g = 2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    vect = matr.col(g);
+    for(i = 0; i < matr.cols(); i++)
+    {
+        if(matr.at(i,g) == vect.at(i))
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, row)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathVectorT<rows, double> vect;
+    uint i;
+    uint g = 2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    vect = matr.row(g);
+    for(i = 0; i < matr.rows(); i++)
+    {
+        if(matr.at(g,i) == vect.at(i))
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, setCol)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathVectorT<rows, double> vect;
+    vect.at(0) = 1.0;
+    vect.at(1) = 3.0;
+    vect.at(2) = 5.0;
+    uint g = 1;
+    uint i = 0;
+    bool b;
+    matr.setCol(g, vect);
+    for(i = 0; i < vect.size(); i++)
+    {
+        if(matr.at(i,g) == vect.at(i))
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, setRow)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathVectorT<rows, double> vect;
+    vect.at(0) = 1.0;
+    vect.at(1) = 3.0;
+    vect.at(2) = 5.0;
+    uint g = 1;
+    uint i = 0;
+    bool b;
+    matr.setRow(g, vect);
+    for(i = 0; i < vect.size(); i++)
+    {
+        if(matr.at(g,i) == vect.at(i))
+        {
+            b = true;
+        }
+        else
+        {
+            b = false;
+            break;
+        }
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, swapCols)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathVectorT<rows, double> before_Vect1;
+    PIMathVectorT<rows, double> before_Vect2;
+    PIMathVectorT<rows, double> after_Vect1;
+    PIMathVectorT<rows, double> after_Vect2;
+    int g1 = 1, g2 = 2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    before_Vect1 = matr.col(g1);
+    before_Vect2 = matr.col(g2);
+    matr.swapCols(g1,g2);
+    after_Vect1 = matr.col(g1);
+    after_Vect2 = matr.col(g2);
+    if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, swapRows)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathVectorT<rows, double> before_Vect1;
+    PIMathVectorT<rows, double> before_Vect2;
+    PIMathVectorT<rows, double> after_Vect1;
+    PIMathVectorT<rows, double> after_Vect2;
+    int g1 = 1, g2 = 2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    before_Vect1 = matr.row(g1);
+    before_Vect2 = matr.row(g2);
+    matr.swapRows(g1,g2);
+    after_Vect1 = matr.row(g1);
+    after_Vect2 = matr.row(g2);
+    if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, fill)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathMatrixT<rows, cols, double> matrix1;
+    double g = 1.0;
+    matr.fill(g);
+    uint j = 0, i = 0;
+    for(i = 0; i < cols; i++)
+    {
+        for(j = 0; j < rows; j++)
+        {
+            matrix1.at(j,i) = g;
+        }
+    }
+    ASSERT_TRUE(matr == matrix1);
+}
+
+TEST(PIMathMatrixT_Test, isSquare)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathMatrixT<rows, cols, double> matrix1;
+    const uint new_Cols = 4;
+    PIMathMatrixT<rows, new_Cols, double> matrix2;
+    bool b;
+    if((matrix1.isSquare() == true) && (matrix2.isSquare() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, isIdentity)
+{
+    PIMathMatrixT<rows, cols, double> matr;
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix1 = matr.identity();
+    matrix2 = matr.filled(3.67);
+    if((matrix1.isIdentity() == true) && (matrix2.isIdentity() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, isNull)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matr;
+    bool b;
+    matrix2 = matr.filled(3.67);
+    if((matrix1.isNull() == true) && (matrix2.isNull() == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Assignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matr;
+    bool b;
+    matrix2.fill(6.72);
+    matrix1 = matrix2;
+    b = cmpMatrixWithValue(matrix1, 6.72);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Equal)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matr;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix1 = matr;
+    matrix2 = matr;
+    matrix2.at(2, 2) = 232;
+    if(((matr == matrix1) == true) && ((matr == matrix2) == false))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Not_Equal)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    PIMathMatrixT<rows, cols, double> matr;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix1 = matr;
+    matrix2 = matr;
+    matrix2.at(2, 2) = 232;
+    if(((matr != matrix1) == false) && ((matr != matrix2) == true))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Addition_Aassignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix2.fill(6.72);
+    matrix1.fill(1.0);
+    matrix1 += matrix2;
+    b = cmpMatrixWithValue(matrix1, 7.72);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Subtraction_Assignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix2.fill(6.72);
+    matrix1.fill(1.0);
+    matrix1 -= matrix2;
+    b = cmpMatrixWithValue(matrix1, -5.72);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Multiplication_Assignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    bool b;
+    matrix1.fill(6.72);
+    matrix1 *= 2.0;
+    b = cmpMatrixWithValue(matrix1, 13.44);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Division_Assignment)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    bool b;
+    matrix1.fill(6.72);
+    matrix1 /= 2.0;
+    b = cmpMatrixWithValue(matrix1, 3.36);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Addition)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix1.fill(6.72);
+    matrix2.fill(8.28);
+    b = cmpMatrixWithValue(matrix1 + matrix2, 15.0);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Subtraction)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix1.fill(6.0);
+    matrix2.fill(5.0);
+    b = cmpMatrixWithValue(matrix1 - matrix2, 1.0);
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, operator_Multiplication)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix1.fill(6.72);
+    matrix2 = matrix1*4.0;
+    b = cmpMatrixWithValue(matrix2, 26.88);
+    ASSERT_TRUE(b);
+}
+TEST(PIMathMatrixT_Test, operator_Division)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    bool b;
+    matrix1.fill(6.72);
+    matrix2 = matrix1/4.0;
+    b = cmpMatrixWithValue(matrix2, 1.68);
+    ASSERT_TRUE(b);
+}
+
+
+TEST(PIMathMatrixT_Test, determinant)
+{
+    double d;
+    double i = 59.0;
+    PIMathMatrixT<rows, cols, double> matr;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    d = matr.determinant();
+    ASSERT_DOUBLE_EQ(i, d);
+}
+
+TEST(PIMathMatrixT_Test, invert)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matrix3;
+    PIMathMatrixT<rows, cols, double> matr;
+    double d1, d2;
+    bool b;
+    matrix1 = matr.identity();
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix2 = matr;
+    matr.invert();
+    d1 = matr.determinant();
+    d2 = matrix2.determinant();
+    matrix3 = matrix1;
+    matrix1.invert();
+    if((matrix1 == matrix3) && (d1 == 1/d2))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, inverted)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matrix3;
+    PIMathMatrixT<rows, cols, double> matr;
+    double d1, d2;
+    bool b;
+    matrix1 = matr.identity();
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix2 = matr.inverted();
+    d1 = matr.determinant();
+    d2 = matrix2.determinant();
+    matrix3 = matrix1.inverted();
+    if((matrix1 == matrix3) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, toUpperTriangular)
+{
+    PIMathMatrixT<rows, cols, double> matrix;
+    double d1, d2 = 1;
+    uint i;
+    PIMathMatrixT<rows, cols, double> matr;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    matrix = matr.toUpperTriangular();
+    d1 = matrix.determinant();
+    for(i = 0; i < cols; i++)
+    {
+        d2 = d2*matrix.at(i,i);
+    }
+    ASSERT_DOUBLE_EQ(d1, d2);
+}
+
+TEST(PIMathMatrixT_Test, transposed)
+{
+    PIMathMatrixT<rows, cols, double> matrix1;
+    PIMathMatrixT<rows, cols, double> matrix2;
+    PIMathMatrixT<rows, cols, double> matr;
+    double d1, d2;
+    bool b;
+    matr.at(0,0) = 3;
+    matr.at(0,1) = 6;
+    matr.at(0,2) = 8;
+    matr.at(1,0) = 2;
+    matr.at(1,1) = 1;
+    matr.at(1,2) = 4;
+    matr.at(2,0) = 6;
+    matr.at(2,1) = 2;
+    matr.at(2,2) = 5;
+    d1 = matr.determinant();
+    matrix1 = matr.transposed();
+    d2 = matrix1.determinant();
+    matrix2 = matrix1.transposed();
+    if((d1 == d2) && (matr == matrix2))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, rotation)
+{
+    double angle = 1.0;
+    bool b;
+    PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::rotation(angle);
+    double c = cos(angle);
+    double s = sin(angle);
+    if((c == matrix.at(1u,1u)) && (c == matrix.at(0u,0u)) && (-s == matrix.at(0u,1u)) && (s == matrix.at(1u,0u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleX_two)
+{
+    double factor = 5.64;
+    bool b;
+    PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleX(factor);
+
+    if((1.0 == matrix.at(1u,1u)) && (factor == matrix.at(0u,0u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleY_two)
+{
+    double factor = 5.64;
+    bool b;
+    PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleY(factor);
+
+    if((factor == matrix.at(1u,1u)) && (1.0 == matrix.at(0u,0u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, rotationX)
+{
+    double angle = 1.0;
+    bool b;
+    double c = cos(angle);
+    double s = sin(angle);
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationX(angle);
+
+    if((1.0 == matrix.at(0u,0u)) && (c == matrix.at(1u,1u)) && (c == matrix.at(2u,2u)) && (s == matrix.at(2u,1u)) && (-s == matrix.at(1u,2u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, rotationY)
+{
+    double angle = 1.0;
+    bool b;
+    double c = cos(angle);
+    double s = sin(angle);
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationY(angle);
+
+    if((1.0 == matrix.at(1u,1u)) && (c == matrix.at(0u,0u)) && (c == matrix.at(2u,2u)) && (s == matrix.at(0u,2u)) && (-s == matrix.at(2u,0u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, rotationZ)
+{
+    double angle = 1.0;
+    bool b;
+    double c = cos(angle);
+    double s = sin(angle);
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationZ(angle);
+
+    if((1.0 == matrix.at(2u,2u)) && (c == matrix.at(0u,0u)) && (c == matrix.at(1u,1u)) && (s == matrix.at(1u,0u)) && (-s == matrix.at(0u,1u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleX_three)
+{
+    double factor = 23.65;
+    bool b;
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleX(factor);
+    if((1.0 == matrix.at(2u,2u)) && (factor == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleY_three)
+{
+    double factor = 23.65;
+    bool b;
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleY(factor);
+    if((1.0 == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (factor == matrix.at(1u,1u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+
+TEST(PIMathMatrixT_Test, scaleZ_three)
+{
+    double factor = 23.65;
+    bool b;
+    PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleZ(factor);
+    if((factor == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u)))
+    {
+        b = true;
+    }
+    else
+    {
+        b = false;
+    }
+    ASSERT_TRUE(b);
+}
+