diff --git a/src/Base/BoundBox.h b/src/Base/BoundBox.h
index b88a463bab..a503203278 100644
--- a/src/Base/BoundBox.h
+++ b/src/Base/BoundBox.h
@@ -65,7 +65,7 @@ public:
                                _Precision fMaxZ = -std::numeric_limits<_Precision>::max());
     BoundBox3 (const BoundBox3<_Precision> &rcBB) { *this = rcBB; }
     /** Builds box from an array of points. */
-    inline BoundBox3 (const Vector3<_Precision> *pclVect, unsigned long ulCt);
+    inline BoundBox3 (const Vector3<_Precision> *pclVect, std::size_t ulCt);
 
     /** Defines a bounding box around the center \a rcCnt with the
      * distances \a fDistance in each coordinate.
@@ -232,7 +232,7 @@ inline BoundBox3<_Precision>::BoundBox3 (_Precision fMinX, _Precision fMinY, _Pr
 }
 
 template <class _Precision>
-inline BoundBox3<_Precision>::BoundBox3 (const Vector3<_Precision> *pclVect, unsigned long ulCt)
+inline BoundBox3<_Precision>::BoundBox3 (const Vector3<_Precision> *pclVect, std::size_t ulCt)
   : MinX( std::numeric_limits<_Precision>::max())
   , MinY( std::numeric_limits<_Precision>::max())
   , MinZ( std::numeric_limits<_Precision>::max())
diff --git a/src/Base/DualQuaternion.h b/src/Base/DualQuaternion.h
index 7ca3b7b1d7..62a85a019f 100644
--- a/src/Base/DualQuaternion.h
+++ b/src/Base/DualQuaternion.h
@@ -94,14 +94,14 @@ public:
     //}
 };
 
-DualQuat operator+(DualQuat a, DualQuat b);
-DualQuat operator-(DualQuat a, DualQuat b);
-DualQuat operator*(DualQuat a, DualQuat b);
+BaseExport DualQuat operator+(DualQuat a, DualQuat b);
+BaseExport DualQuat operator-(DualQuat a, DualQuat b);
+BaseExport DualQuat operator*(DualQuat a, DualQuat b);
 
-DualQuat operator*(DualQuat a, double b);
-DualQuat operator*(double a, DualQuat b);
-DualQuat operator*(DualQuat a, DualNumber b);
-DualQuat operator*(DualNumber a, DualQuat b);
+BaseExport DualQuat operator*(DualQuat a, double b);
+BaseExport DualQuat operator*(double a, DualQuat b);
+BaseExport DualQuat operator*(DualQuat a, DualNumber b);
+BaseExport DualQuat operator*(DualNumber a, DualQuat b);
 
 
 } //namespace
diff --git a/tests/src/App/CMakeLists.txt b/tests/src/App/CMakeLists.txt
index 8a98989dc9..2e3019782a 100644
--- a/tests/src/App/CMakeLists.txt
+++ b/tests/src/App/CMakeLists.txt
@@ -11,5 +11,6 @@ target_sources(
             ${CMAKE_CURRENT_SOURCE_DIR}/MappedElement.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/MappedName.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/Metadata.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/Property.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/StringHasher.cpp
 )
diff --git a/tests/src/App/Property.cpp b/tests/src/App/Property.cpp
new file mode 100644
index 0000000000..1bcc2d78b8
--- /dev/null
+++ b/tests/src/App/Property.cpp
@@ -0,0 +1,15 @@
+#include "gtest/gtest.h"
+
+#include "App/PropertyLinks.h"
+
+TEST(PropertyLink, TestSetValues)
+{
+    App::PropertyLinkSubList prop;
+    std::vector<App::DocumentObject*> objs {nullptr, nullptr};
+    std::vector<const char*> subs {"Sub1", "Sub2"};
+    prop.setValues(objs, subs);
+    const auto& sub = prop.getSubValues();
+    EXPECT_EQ(sub.size(), 2);
+    EXPECT_EQ(sub[0], "Sub1");
+    EXPECT_EQ(sub[1], "Sub2");
+}
diff --git a/tests/src/Base/Axis.cpp b/tests/src/Base/Axis.cpp
new file mode 100644
index 0000000000..4665260aed
--- /dev/null
+++ b/tests/src/Base/Axis.cpp
@@ -0,0 +1,69 @@
+#include "gtest/gtest.h"
+#include <Base/Axis.h>
+
+TEST(Axis, TestDefault)
+{
+    Base::Axis axis;
+    EXPECT_EQ(axis.getBase(), Base::Vector3d());
+    EXPECT_EQ(axis.getDirection(), Base::Vector3d());
+}
+
+TEST(Axis, TestCustom)
+{
+    Base::Axis axis(Base::Vector3d(0, 0, 1), Base::Vector3d(1, 1, 1));
+    EXPECT_EQ(axis.getBase(), Base::Vector3d(0, 0, 1));
+    EXPECT_EQ(axis.getDirection(), Base::Vector3d(1, 1, 1));
+}
+
+TEST(Axis, TestSetter)
+{
+    Base::Axis axis;
+    axis.setBase(Base::Vector3d(0, 0, 1));
+    axis.setDirection(Base::Vector3d(1, 1, 1));
+    EXPECT_EQ(axis.getBase(), Base::Vector3d(0, 0, 1));
+    EXPECT_EQ(axis.getDirection(), Base::Vector3d(1, 1, 1));
+}
+
+TEST(Axis, TestAssign)
+{
+    Base::Axis axis;
+    Base::Axis move;
+    axis.setBase(Base::Vector3d(0, 0, 1));
+    axis.setDirection(Base::Vector3d(1, 1, 1));
+    move = std::move(axis);// NOLINT
+    EXPECT_EQ(move.getBase(), Base::Vector3d(0, 0, 1));
+    EXPECT_EQ(move.getDirection(), Base::Vector3d(1, 1, 1));
+}
+
+TEST(Axis, TestReverse)
+{
+    Base::Axis axis(Base::Vector3d(0, 0, 1), Base::Vector3d(1, 1, 1));
+    axis.reverse();
+    EXPECT_EQ(axis.getBase(), Base::Vector3d(0, 0, 1));
+    EXPECT_EQ(axis.getDirection(), Base::Vector3d(-1, -1, -1));
+}
+
+TEST(Axis, TestReversed)
+{
+    Base::Axis axis(Base::Vector3d(0, 0, 1), Base::Vector3d(1, 1, 1));
+    Base::Axis rev(axis.reversed());
+    EXPECT_EQ(axis.getDirection(), Base::Vector3d(1, 1, 1));
+    EXPECT_EQ(rev.getBase(), Base::Vector3d(0, 0, 1));
+    EXPECT_EQ(rev.getDirection(), Base::Vector3d(-1, -1, -1));
+}
+
+TEST(Axis, TestMove)
+{
+    Base::Axis axis(Base::Vector3d(0, 0, 1), Base::Vector3d(1, 1, 1));
+    axis.move(Base::Vector3d(1, 2, 3));
+    EXPECT_EQ(axis.getBase(), Base::Vector3d(1, 2, 4));
+    EXPECT_EQ(axis.getDirection(), Base::Vector3d(1, 1, 1));
+}
+
+TEST(Axis, TestMult)
+{
+    Base::Axis axis(Base::Vector3d(0, 0, 1), Base::Vector3d(0, 0, 1));
+    axis *= Base::Placement(Base::Vector3d(1, 1, 1), Base::Rotation(1, 0, 0, 0));
+    EXPECT_EQ(axis.getBase(), Base::Vector3d(1, 1, 0));
+    EXPECT_EQ(axis.getDirection(), Base::Vector3d(0, 0, -1));
+}
diff --git a/tests/src/Base/BoundBox.cpp b/tests/src/Base/BoundBox.cpp
new file mode 100644
index 0000000000..139de86bc1
--- /dev/null
+++ b/tests/src/Base/BoundBox.cpp
@@ -0,0 +1,269 @@
+#include "gtest/gtest.h"
+#include <Base/BoundBox.h>
+#include <boost/beast/core/span.hpp>
+
+// NOLINTBEGIN(cppcoreguidelines-*,readability-*)
+TEST(BoundBox, TestDefault)
+{
+    Base::BoundBox3d box;
+    EXPECT_EQ(box.IsValid(), false);
+}
+
+TEST(BoundBox, TestVoid)
+{
+    Base::BoundBox3d box;
+    EXPECT_EQ(box.IsValid(), false);
+    box.Add(Base::Vector3d(0, 0, 0));
+    EXPECT_EQ(box.IsValid(), true);
+    box.SetVoid();
+    EXPECT_EQ(box.IsValid(), false);
+}
+
+TEST(BoundBox, TestCopy)
+{
+    Base::BoundBox3d box;
+    box.Add(Base::Vector3d(0, 0, 0));
+    box.Add(Base::Vector3d(1, 1, 1));
+    Base::BoundBox3d copy(box);
+    EXPECT_EQ(copy.IsValid(), true);
+    EXPECT_EQ(copy.MinX, 0);
+    EXPECT_EQ(copy.MinY, 0);
+    EXPECT_EQ(copy.MinZ, 0);
+    EXPECT_EQ(copy.MaxX, 1);
+    EXPECT_EQ(copy.MaxY, 1);
+    EXPECT_EQ(copy.MaxZ, 1);
+}
+
+TEST(BoundBox, TestAssign)
+{
+    Base::BoundBox3d box;
+    box.Add(Base::Vector3d(0, 0, 0));
+    box.Add(Base::Vector3d(1, 1, 1));
+    Base::BoundBox3d copy;
+    copy = box;
+    EXPECT_EQ(copy.IsValid(), true);
+    EXPECT_EQ(copy.MinX, 0);
+    EXPECT_EQ(copy.MinY, 0);
+    EXPECT_EQ(copy.MinZ, 0);
+    EXPECT_EQ(copy.MaxX, 1);
+    EXPECT_EQ(copy.MaxY, 1);
+    EXPECT_EQ(copy.MaxZ, 1);
+}
+
+TEST(BoundBox, TestPoints)
+{
+    std::array<Base::Vector3d, 1> pts;
+    Base::BoundBox3d box(pts.data(), pts.size());
+    EXPECT_EQ(box.IsValid(), true);
+    EXPECT_EQ(box.MinX, 0);
+    EXPECT_EQ(box.MinY, 0);
+    EXPECT_EQ(box.MinZ, 0);
+    EXPECT_EQ(box.MaxX, 0);
+    EXPECT_EQ(box.MaxY, 0);
+    EXPECT_EQ(box.MaxZ, 0);
+}
+
+TEST(BoundBox, TestDistance)
+{
+    Base::BoundBox3d box(Base::Vector3d(0, 0, 0), 0.5);
+    EXPECT_EQ(box.IsValid(), true);
+    EXPECT_EQ(box.MinX, -0.5);
+    EXPECT_EQ(box.MinY, -0.5);
+    EXPECT_EQ(box.MinZ, -0.5);
+    EXPECT_EQ(box.MaxX, 0.5);
+    EXPECT_EQ(box.MaxY, 0.5);
+    EXPECT_EQ(box.MaxZ, 0.5);
+}
+
+Base::BoundBox3d createBox(boost::beast::span<Base::Vector3d> span)
+{
+    return {span.data(), span.size()};
+}
+
+TEST(BoundBox, TestEmptySpan)
+{
+    Base::BoundBox3d box = createBox({});
+    EXPECT_EQ(box.IsValid(), false);
+}
+
+TEST(BoundBox, TestNonEmptySpan)
+{
+    std::vector<Base::Vector3d> points = {Base::Vector3d {1.0, 0.0, 0.0},
+                                          Base::Vector3d {0.0, 1.0, 0.0},
+                                          Base::Vector3d {0.0, 0.0, 1.0}};
+    Base::BoundBox3d box = createBox({points.data(), 2});
+    EXPECT_EQ(box.IsValid(), true);
+    EXPECT_EQ(box.MinX, 0);
+    EXPECT_EQ(box.MinY, 0);
+    EXPECT_EQ(box.MinZ, 0);
+    EXPECT_EQ(box.MaxX, 1);
+    EXPECT_EQ(box.MaxY, 1);
+    EXPECT_EQ(box.MaxZ, 0);
+}
+
+TEST(BoundBox, TestArray)
+{
+    std::vector<Base::Vector3d> points = {Base::Vector3d {1.0, 0.0, 0.0},
+                                          Base::Vector3d {0.0, 1.0, 0.0},
+                                          Base::Vector3d {0.0, 0.0, 1.0}};
+    Base::BoundBox3d box(points.data(), points.size());
+    EXPECT_EQ(box.IsValid(), true);
+    EXPECT_EQ(box.MinX, 0);
+    EXPECT_EQ(box.MinY, 0);
+    EXPECT_EQ(box.MinZ, 0);
+    EXPECT_EQ(box.MaxX, 1);
+    EXPECT_EQ(box.MaxY, 1);
+    EXPECT_EQ(box.MaxZ, 1);
+}
+
+TEST(BoundBox, TestIntersect)
+{
+    Base::BoundBox3d box1;
+    Base::BoundBox3d box2;
+    Base::BoundBox3d box3;
+    EXPECT_EQ(box1.Intersect(box1), false);
+    box1.Add(Base::Vector3d(0, 0, 0));
+    EXPECT_EQ(box1.Intersect(box1), true);
+    EXPECT_EQ(box1.Intersect(box2), false);
+    EXPECT_EQ(box2.Intersect(box1), false);
+
+    box1.Add(Base::Vector3d(1, 1, 1));
+    box2.Add(Base::Vector3d(0.5, 0.5, 0.5));
+    box2.Add(Base::Vector3d(1.5, 1.5, 1.5));
+    EXPECT_EQ(box1.Intersect(box2), true);
+    EXPECT_EQ(box2.Intersect(box1), true);
+    EXPECT_EQ(box1 && box2, true);
+    EXPECT_EQ(box2 && box1, true);
+
+    box3 = box1.Intersected(box2);
+    EXPECT_EQ(box3.IsValid(), true);
+}
+
+TEST(BoundBox, TestIntersect2D)
+{
+    Base::BoundBox3d box1;
+    box1.Add(Base::Vector3d(0, 0, 0));
+    box1.Add(Base::Vector3d(1, 1, 1));
+
+    Base::BoundBox2d box2;
+    box2.Add(Base::Vector2d(0.5, 0.5));
+    box2.Add(Base::Vector2d(1.5, 1.5));
+    EXPECT_EQ(box1.Intersect(box2), true);
+    EXPECT_EQ(box1 && box2, true);
+}
+
+TEST(BoundBox, TestUnite)
+{
+    Base::BoundBox3d box1;
+    Base::BoundBox3d box2;
+    Base::BoundBox3d box3;
+    box1.Add(Base::Vector3d(0, 0, 0));
+    box2.Add(Base::Vector3d(1, 1, 1));
+    box3 = box1.United(box2);
+
+    EXPECT_EQ(box3.IsValid(), true);
+    EXPECT_EQ(box3.MinX, 0);
+    EXPECT_EQ(box3.MinY, 0);
+    EXPECT_EQ(box3.MinZ, 0);
+    EXPECT_EQ(box3.MaxX, 1);
+    EXPECT_EQ(box3.MaxY, 1);
+    EXPECT_EQ(box3.MaxZ, 1);
+
+    box1.Add(box2);
+    EXPECT_EQ(box1.IsValid(), true);
+    EXPECT_EQ(box1.MinX, 0);
+    EXPECT_EQ(box1.MinY, 0);
+    EXPECT_EQ(box1.MinZ, 0);
+    EXPECT_EQ(box1.MaxX, 1);
+    EXPECT_EQ(box1.MaxY, 1);
+    EXPECT_EQ(box1.MaxZ, 1);
+}
+
+TEST(BoundBox, TestAdd)
+{
+    Base::BoundBox3d box1;
+    Base::BoundBox3d box2;
+    box1.Add(Base::Vector3d(0, 0, 0));
+    box2.Add(Base::Vector3d(1, 1, 1));
+
+    box1.Add(box2);
+    EXPECT_EQ(box1.IsInBox(box2), true);
+    EXPECT_EQ(box1.IsInBox(Base::Vector3d(0, 0, 0)), true);
+    EXPECT_EQ(box1.IsInBox(Base::Vector3d(1, 1, 1)), true);
+}
+
+TEST(BoundBox, TestCenter)
+{
+    Base::BoundBox3d box;
+    box.Add(Base::Vector3d(0, 0, 0));
+    box.Add(Base::Vector3d(1, 1, 1));
+
+    EXPECT_EQ(box.GetCenter(), Base::Vector3d(0.5, 0.5, 0.5));
+}
+
+TEST(BoundBox, TestDiagonalLength)
+{
+    Base::BoundBox3d box;
+    box.Add(Base::Vector3d(0, 0, 0));
+    box.Add(Base::Vector3d(1, 1, 1));
+
+    EXPECT_GT(box.CalcDiagonalLength(), 1.7);
+    EXPECT_LT(box.CalcDiagonalLength(), 1.8);
+}
+
+TEST(BoundBox, TestDiagonalEnlarge)
+{
+    Base::BoundBox3d box;
+    box.Add(Base::Vector3d(1, 1, 1));
+    box.Enlarge(0.5);
+
+    EXPECT_EQ(box.LengthX(), 1.0);
+    EXPECT_EQ(box.LengthY(), 1.0);
+    EXPECT_EQ(box.LengthZ(), 1.0);
+}
+
+TEST(BoundBox, TestDiagonalShrink)
+{
+    Base::BoundBox3d box;
+    box.Add(Base::Vector3d(0, 0, 0));
+    box.Add(Base::Vector3d(4, 6, 8));
+    box.Shrink(0.5);
+
+    EXPECT_EQ(box.LengthX(), 3.0);
+    EXPECT_EQ(box.LengthY(), 5.0);
+    EXPECT_EQ(box.LengthZ(), 7.0);
+}
+
+TEST(BoundBox, TestDiagonalMove)
+{
+    Base::BoundBox3d box;
+    box.Add(Base::Vector3d(0, 0, 0));
+    box.MoveX(1.0);
+    box.MoveY(2.0);
+    box.MoveZ(3.0);
+
+    EXPECT_EQ(box.MinX, 1);
+    EXPECT_EQ(box.MinY, 2);
+    EXPECT_EQ(box.MinZ, 3);
+    EXPECT_EQ(box.MaxX, 1);
+    EXPECT_EQ(box.MaxY, 2);
+    EXPECT_EQ(box.MaxZ, 3);
+}
+
+TEST(BoundBox, TestDiagonalScale)
+{
+    Base::BoundBox3d box;
+    box.Add(Base::Vector3d(0, 0, 0));
+    box.Add(Base::Vector3d(1, 2, 3));
+    box.ScaleX(0.5);
+    box.ScaleY(1.0);
+    box.ScaleZ(2.0);
+
+    EXPECT_EQ(box.MinX, 0);
+    EXPECT_EQ(box.MinY, 0);
+    EXPECT_EQ(box.MinZ, 0);
+    EXPECT_EQ(box.MaxX, 0.5);
+    EXPECT_EQ(box.MaxY, 2.0);
+    EXPECT_EQ(box.MaxZ, 6.0);
+}
+// NOLINTEND(cppcoreguidelines-*,readability-*)
diff --git a/tests/src/Base/CMakeLists.txt b/tests/src/Base/CMakeLists.txt
index 324d9cf3f3..7f2d163409 100644
--- a/tests/src/Base/CMakeLists.txt
+++ b/tests/src/Base/CMakeLists.txt
@@ -1,14 +1,26 @@
 target_sources(
     Tests_run
         PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/Axis.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/Bitmask.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/BoundBox.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/CoordinateSystem.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/DualNumber.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/DualQuaternion.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/Handle.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/Matrix.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/Placement.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/Quantity.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/Reader.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/Rotation.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/TimeInfo.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/Tools.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/Tools2D.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/Tools3D.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/Unit.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/Vector3D.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/ViewProj.cpp
             ${CMAKE_CURRENT_SOURCE_DIR}/Writer.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/tst_Tools.cpp
 )
 
 setup_qt_test(InventorBuilder)
diff --git a/tests/src/Base/CoordinateSystem.cpp b/tests/src/Base/CoordinateSystem.cpp
new file mode 100644
index 0000000000..3a22aca6f0
--- /dev/null
+++ b/tests/src/Base/CoordinateSystem.cpp
@@ -0,0 +1,150 @@
+#include "gtest/gtest.h"
+#include <Base/CoordinateSystem.h>
+#include <Base/Exception.h>
+
+// NOLINTBEGIN
+TEST(CoordinateSystem, TestDefault)
+{
+    Base::CoordinateSystem cs;
+    EXPECT_EQ(cs.getPosition(), Base::Vector3d(0, 0, 0));
+    EXPECT_EQ(cs.getXDirection(), Base::Vector3d(1, 0, 0));
+    EXPECT_EQ(cs.getYDirection(), Base::Vector3d(0, 1, 0));
+    EXPECT_EQ(cs.getZDirection(), Base::Vector3d(0, 0, 1));
+}
+
+TEST(CoordinateSystem, TestSetAxisFailure)
+{
+    Base::CoordinateSystem cs;
+
+    EXPECT_THROW(cs.setAxes(Base::Vector3d(0, 0, 1), Base::Vector3d(0, 0, 1)), Base::ValueError);
+}
+
+TEST(CoordinateSystem, TestSetAxis)
+{
+    Base::CoordinateSystem cs;
+    Base::Axis axis;
+    axis.setBase(Base::Vector3d(1, 2, 3));
+    axis.setDirection(Base::Vector3d(1, 1, 1));
+    cs.setAxes(axis, Base::Vector3d(0, 0, 1));
+
+    EXPECT_EQ(cs.getPosition(), Base::Vector3d(1, 2, 3));
+    EXPECT_EQ(cs.getXDirection(), Base::Vector3d(-1, -1, 2).Normalize());
+    EXPECT_EQ(cs.getYDirection(), Base::Vector3d(1, -1, 0).Normalize());
+    EXPECT_EQ(cs.getZDirection(), Base::Vector3d(1, 1, 1).Normalize());
+}
+
+TEST(CoordinateSystem, TestSetXDir)
+{
+    Base::CoordinateSystem cs;
+    cs.setXDirection(Base::Vector3d(1, 1, 1));
+
+    EXPECT_EQ(cs.getXDirection(), Base::Vector3d(1, 1, 0).Normalize());
+    EXPECT_EQ(cs.getYDirection(), Base::Vector3d(-1, 1, 0).Normalize());
+    EXPECT_EQ(cs.getZDirection(), Base::Vector3d(0, 0, 1).Normalize());
+}
+
+TEST(CoordinateSystem, TestSetYDir)
+{
+    Base::CoordinateSystem cs;
+    cs.setYDirection(Base::Vector3d(1, 1, 1));
+
+    EXPECT_EQ(cs.getXDirection(), Base::Vector3d(1, -1, 0).Normalize());
+    EXPECT_EQ(cs.getYDirection(), Base::Vector3d(1, 1, 0).Normalize());
+    EXPECT_EQ(cs.getZDirection(), Base::Vector3d(0, 0, 1).Normalize());
+}
+
+TEST(CoordinateSystem, TestSetZDir)
+{
+    Base::CoordinateSystem cs;
+    cs.setZDirection(Base::Vector3d(1, 1, 1));
+
+    EXPECT_EQ(cs.getXDirection(), Base::Vector3d(2, -1, -1).Normalize());
+    EXPECT_EQ(cs.getYDirection(), Base::Vector3d(0, 1, -1).Normalize());
+    EXPECT_EQ(cs.getZDirection(), Base::Vector3d(1, 1, 1).Normalize());
+}
+
+TEST(CoordinateSystem, TestTransformPlacement)
+{
+    Base::CoordinateSystem cs;
+    Base::CoordinateSystem csT;
+    Base::Placement plm;
+    plm.setPosition(Base::Vector3d(1, 2, 3));
+    plm.setRotation(Base::Rotation(1, 1, 2, 2));
+    csT.transform(plm);
+
+    Base::Placement dis = cs.displacement(csT);
+    EXPECT_EQ(plm, dis);
+
+    Base::Placement disT = csT.displacement(cs);
+    EXPECT_EQ(plm.inverse(), disT);
+}
+
+TEST(CoordinateSystem, TestMultTransformPlacement)
+{
+    Base::CoordinateSystem cs;
+    Base::CoordinateSystem csT;
+    Base::Placement plm;
+    plm.setPosition(Base::Vector3d(1, 2, 3));
+    plm.setRotation(Base::Rotation(1, 1, 2, 2));
+    csT.transform(plm);
+    csT.transform(plm);
+
+    plm = plm * plm;
+
+    Base::Placement dis = cs.displacement(csT);
+    EXPECT_EQ(plm.isSame(dis, 0.001), true);
+
+    Base::Placement disT = csT.displacement(cs);
+    EXPECT_EQ(plm.inverse().isSame(disT, 0.001), true);
+}
+
+TEST(CoordinateSystem, TestTransformRotation)
+{
+    Base::CoordinateSystem cs;
+    Base::CoordinateSystem csT;
+    Base::Rotation rot(1, 1, 2, 2);
+    csT.transform(rot);
+
+    Base::Placement dis = cs.displacement(csT);
+    EXPECT_EQ(rot, dis.getRotation());
+
+    Base::Placement disT = csT.displacement(cs);
+    EXPECT_EQ(rot.inverse(), disT.getRotation());
+}
+
+TEST(CoordinateSystem, TestTransformPoint)
+{
+    Base::CoordinateSystem cs;
+    Base::CoordinateSystem csT;
+    Base::Placement plm;
+    plm.setPosition(Base::Vector3d(1, 2, 3));
+    plm.setRotation(Base::Rotation(1, 1, 2, 2));
+    csT.transform(plm);
+
+    Base::Vector3d src(-1, 5, 3), dst;
+    plm.inverse().multVec(src, dst);
+    csT.transformTo(src);
+
+    EXPECT_EQ(src, dst);
+}
+
+TEST(CoordinateSystem, TestSetPlacement)
+{
+    Base::CoordinateSystem cs;
+    Base::CoordinateSystem csT;
+    Base::Placement plm;
+    plm.setPosition(Base::Vector3d(1, 2, 3));
+    plm.setRotation(Base::Rotation(1, 1, 2, 2));
+    csT.transform(plm);
+    csT.transform(plm);
+    csT.transform(plm);
+    csT.setPlacement(plm);
+
+    Base::Placement dis = cs.displacement(csT);
+    EXPECT_EQ(plm, dis);
+
+    Base::Placement disT = csT.displacement(cs);
+    EXPECT_EQ(plm.inverse(), disT);
+}
+
+// NOLINTEND
diff --git a/tests/src/Base/DualNumber.cpp b/tests/src/Base/DualNumber.cpp
new file mode 100644
index 0000000000..6d733e82e6
--- /dev/null
+++ b/tests/src/Base/DualNumber.cpp
@@ -0,0 +1,103 @@
+#include "gtest/gtest.h"
+#include <Base/DualNumber.h>
+
+TEST(DualNumber, TestDefault)
+{
+    Base::DualNumber dn;
+    EXPECT_EQ(dn.re, 0.0);
+    EXPECT_EQ(dn.du, 0.0);
+}
+
+TEST(DualNumber, TestNonDefault)
+{
+    Base::DualNumber dn(1.0);
+    EXPECT_EQ(dn.re, 1.0);
+    EXPECT_EQ(dn.du, 0.0);
+
+    Base::DualNumber dn2(1.0, 2.0);
+    EXPECT_EQ(dn2.re, 1.0);
+    EXPECT_EQ(dn2.du, 2.0);
+}
+
+TEST(DualNumber, TestNegate)
+{
+    Base::DualNumber dn(-Base::DualNumber(1.0, 2.0));
+    EXPECT_EQ(dn.re, -1.0);
+    EXPECT_EQ(dn.du, -2.0);
+}
+
+TEST(DualNumber, TestPlus)
+{
+    Base::DualNumber dn1(1.0, 2.0);
+    Base::DualNumber dn2(2.0, -1.0);
+
+    Base::DualNumber dn3 = dn1 + dn2;
+    EXPECT_EQ(dn3.re, 3.0);
+    EXPECT_EQ(dn3.du, 1.0);
+
+    Base::DualNumber dn4 = dn1 + 2.0;
+    EXPECT_EQ(dn4.re, 3.0);
+    EXPECT_EQ(dn4.du, 2.0);
+
+    Base::DualNumber dn5 = 2.0 + dn1;
+    EXPECT_EQ(dn5.re, 3.0);
+    EXPECT_EQ(dn5.du, 2.0);
+}
+
+TEST(DualNumber, TestMinus)
+{
+    Base::DualNumber dn1(1.0, 2.0);
+    Base::DualNumber dn2(2.0, -1.0);
+
+    Base::DualNumber dn3 = dn1 - dn2;
+    EXPECT_EQ(dn3.re, -1.0);
+    EXPECT_EQ(dn3.du, 3.0);
+
+    Base::DualNumber dn4 = dn1 - 2.0;
+    EXPECT_EQ(dn4.re, -1.0);
+    EXPECT_EQ(dn4.du, 2.0);
+
+    Base::DualNumber dn5 = 2.0 - dn1;
+    EXPECT_EQ(dn5.re, 1.0);
+    EXPECT_EQ(dn5.du, -2.0);
+}
+
+TEST(DualNumber, TestMultiply)
+{
+    Base::DualNumber dn1(1.0, 2.0);
+    Base::DualNumber dn2(2.0, -1.0);
+
+    Base::DualNumber dn3 = dn1 * dn2;
+    EXPECT_EQ(dn3.re, 2.0);
+    EXPECT_EQ(dn3.du, 3.0);
+
+    Base::DualNumber dn4 = dn1 * 2.0;
+    EXPECT_EQ(dn4.re, 2.0);
+    EXPECT_EQ(dn4.du, 4.0);
+
+    Base::DualNumber dn5 = 2.0 * dn1;
+    EXPECT_EQ(dn5.re, 2.0);
+    EXPECT_EQ(dn5.du, 4.0);
+}
+
+TEST(DualNumber, TestDivide)
+{
+    Base::DualNumber dn1(1.0, 2.0);
+    Base::DualNumber dn2(2.0, -1.0);
+
+    Base::DualNumber dn3 = dn1 / dn2;
+    EXPECT_EQ(dn3.re, 0.5);
+    EXPECT_EQ(dn3.du, 1.25);
+
+    Base::DualNumber dn4 = dn1 / 2.0;
+    EXPECT_EQ(dn4.re, 0.5);
+    EXPECT_EQ(dn4.du, 1.0);
+}
+
+TEST(DualNumber, TestPow)
+{
+    Base::DualNumber dn1(3.0, 2.0);
+    Base::DualNumber dn2 = Base::pow(dn1, 2.0);
+    EXPECT_EQ(dn2.re, 9.0);
+    EXPECT_EQ(dn2.du, 12.0);
+}
diff --git a/tests/src/Base/DualQuaternion.cpp b/tests/src/Base/DualQuaternion.cpp
new file mode 100644
index 0000000000..950e1542b4
--- /dev/null
+++ b/tests/src/Base/DualQuaternion.cpp
@@ -0,0 +1,266 @@
+#include "gtest/gtest.h"
+#include <Base/DualQuaternion.h>
+#include <Base/Tools.h>
+
+TEST(DualQuaternion, TestDefault)
+{
+    Base::DualQuat qq;
+    EXPECT_EQ(qq.x.re, 0.0);
+    EXPECT_EQ(qq.x.du, 0.0);
+    EXPECT_EQ(qq.y.re, 0.0);
+    EXPECT_EQ(qq.y.du, 0.0);
+    EXPECT_EQ(qq.z.re, 0.0);
+    EXPECT_EQ(qq.z.du, 0.0);
+    EXPECT_EQ(qq.w.re, 0.0);
+    EXPECT_EQ(qq.w.du, 0.0);
+}
+
+TEST(DualQuaternion, TestFromDouble)
+{
+    Base::DualQuat qq(1.0, 2.0, 3.0, 4.0);
+    EXPECT_EQ(qq.x.re, 1.0);
+    EXPECT_EQ(qq.x.du, 0.0);
+    EXPECT_EQ(qq.y.re, 2.0);
+    EXPECT_EQ(qq.y.du, 0.0);
+    EXPECT_EQ(qq.z.re, 3.0);
+    EXPECT_EQ(qq.z.du, 0.0);
+    EXPECT_EQ(qq.w.re, 4.0);
+    EXPECT_EQ(qq.w.du, 0.0);
+}
+
+TEST(DualQuaternion, TestFromDoubles)
+{
+    Base::DualQuat qq(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+    EXPECT_EQ(qq.x.re, 1.0);
+    EXPECT_EQ(qq.x.du, 5.0);
+    EXPECT_EQ(qq.y.re, 2.0);
+    EXPECT_EQ(qq.y.du, 6.0);
+    EXPECT_EQ(qq.z.re, 3.0);
+    EXPECT_EQ(qq.z.du, 7.0);
+    EXPECT_EQ(qq.w.re, 4.0);
+    EXPECT_EQ(qq.w.du, 8.0);
+}
+
+TEST(DualQuaternion, TestFromDual)
+{
+    Base::DualNumber dn(1.0, 2.0);
+    Base::DualQuat qq(dn, dn, dn, dn);
+    EXPECT_EQ(qq.x.re, 1.0);
+    EXPECT_EQ(qq.x.du, 2.0);
+    EXPECT_EQ(qq.y.re, 1.0);
+    EXPECT_EQ(qq.y.du, 2.0);
+    EXPECT_EQ(qq.z.re, 1.0);
+    EXPECT_EQ(qq.z.du, 2.0);
+    EXPECT_EQ(qq.w.re, 1.0);
+    EXPECT_EQ(qq.w.du, 2.0);
+}
+
+TEST(DualQuaternion, TestIdentity)
+{
+    Base::DualQuat qq = Base::DualQuat::identity();
+    EXPECT_EQ(qq.x.re, 0.0);
+    EXPECT_EQ(qq.x.du, 0.0);
+    EXPECT_EQ(qq.y.re, 0.0);
+    EXPECT_EQ(qq.y.du, 0.0);
+    EXPECT_EQ(qq.z.re, 0.0);
+    EXPECT_EQ(qq.z.du, 0.0);
+    EXPECT_EQ(qq.w.re, 1.0);
+    EXPECT_EQ(qq.w.du, 0.0);
+}
+
+TEST(DualQuaternion, TestReal)
+{
+    Base::DualQuat qq = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0).real();
+    EXPECT_EQ(qq.x.re, 1.0);
+    EXPECT_EQ(qq.x.du, 0.0);
+    EXPECT_EQ(qq.y.re, 2.0);
+    EXPECT_EQ(qq.y.du, 0.0);
+    EXPECT_EQ(qq.z.re, 3.0);
+    EXPECT_EQ(qq.z.du, 0.0);
+    EXPECT_EQ(qq.w.re, 4.0);
+    EXPECT_EQ(qq.w.du, 0.0);
+}
+
+TEST(DualQuaternion, TestDual)
+{
+    Base::DualQuat qq = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0).dual();
+    EXPECT_EQ(qq.x.re, 5.0);
+    EXPECT_EQ(qq.x.du, 0.0);
+    EXPECT_EQ(qq.y.re, 6.0);
+    EXPECT_EQ(qq.y.du, 0.0);
+    EXPECT_EQ(qq.z.re, 7.0);
+    EXPECT_EQ(qq.z.du, 0.0);
+    EXPECT_EQ(qq.w.re, 8.0);
+    EXPECT_EQ(qq.w.du, 0.0);
+}
+
+TEST(DualQuaternion, TestConjugate)
+{
+    Base::DualQuat qq = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0).conj();
+    EXPECT_EQ(qq.x.re, -1.0);
+    EXPECT_EQ(qq.x.du, -5.0);
+    EXPECT_EQ(qq.y.re, -2.0);
+    EXPECT_EQ(qq.y.du, -6.0);
+    EXPECT_EQ(qq.z.re, -3.0);
+    EXPECT_EQ(qq.z.du, -7.0);
+    EXPECT_EQ(qq.w.re, 4.0);
+    EXPECT_EQ(qq.w.du, 8.0);
+}
+
+TEST(DualQuaternion, TestVec)
+{
+    Base::DualQuat qq = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0).vec();
+    EXPECT_EQ(qq.x.re, 1.0);
+    EXPECT_EQ(qq.x.du, 5.0);
+    EXPECT_EQ(qq.y.re, 2.0);
+    EXPECT_EQ(qq.y.du, 6.0);
+    EXPECT_EQ(qq.z.re, 3.0);
+    EXPECT_EQ(qq.z.du, 7.0);
+    EXPECT_EQ(qq.w.re, 0.0);
+    EXPECT_EQ(qq.w.du, 0.0);
+}
+
+TEST(DualQuaternion, TestLength)
+{
+    Base::DualQuat qq = Base::DualQuat(0.0, 0.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+    EXPECT_DOUBLE_EQ(qq.length(), 5.0);
+}
+
+TEST(DualQuaternion, TestTheta)
+{
+    Base::DualQuat qq = Base::DualQuat(0.0, 0.0, 3.0, 3.0, 5.0, 6.0, 7.0, 8.0);
+    EXPECT_DOUBLE_EQ(qq.theta(), Base::toRadians(90.0));
+}
+
+TEST(DualQuaternion, TestDot)
+{
+    Base::DualQuat qq1 = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+    Base::DualQuat qq2 = Base::DualQuat(1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0);
+    double dot = Base::DualQuat::dot(qq1, qq2);
+    EXPECT_DOUBLE_EQ(dot, 10.0);
+}
+
+TEST(DualQuaternion, TestNegate)
+{
+    Base::DualQuat qq = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+    Base::DualQuat dn(-qq);
+    EXPECT_EQ(dn.x.re, -1.0);
+    EXPECT_EQ(dn.x.du, -5.0);
+    EXPECT_EQ(dn.y.re, -2.0);
+    EXPECT_EQ(dn.y.du, -6.0);
+    EXPECT_EQ(dn.z.re, -3.0);
+    EXPECT_EQ(dn.z.du, -7.0);
+    EXPECT_EQ(dn.w.re, -4.0);
+    EXPECT_EQ(dn.w.du, -8.0);
+}
+
+TEST(DualQuaternion, TestPlus)
+{
+    Base::DualQuat qq1 = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+    Base::DualQuat qq2 = Base::DualQuat(1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0);
+    Base::DualQuat qq3 = qq1 + qq2;
+    EXPECT_EQ(qq3.x.re, 2.0);
+    EXPECT_EQ(qq3.x.du, 7.0);
+    EXPECT_EQ(qq3.y.re, 3.0);
+    EXPECT_EQ(qq3.y.du, 8.0);
+    EXPECT_EQ(qq3.z.re, 4.0);
+    EXPECT_EQ(qq3.z.du, 9.0);
+    EXPECT_EQ(qq3.w.re, 5.0);
+    EXPECT_EQ(qq3.w.du, 10.0);
+}
+
+TEST(DualQuaternion, TestMinus)
+{
+    Base::DualQuat qq1 = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+    Base::DualQuat qq2 = Base::DualQuat(1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0);
+    Base::DualQuat qq3 = qq1 - qq2;
+    EXPECT_EQ(qq3.x.re, 0.0);
+    EXPECT_EQ(qq3.x.du, 3.0);
+    EXPECT_EQ(qq3.y.re, 1.0);
+    EXPECT_EQ(qq3.y.du, 4.0);
+    EXPECT_EQ(qq3.z.re, 2.0);
+    EXPECT_EQ(qq3.z.du, 5.0);
+    EXPECT_EQ(qq3.w.re, 3.0);
+    EXPECT_EQ(qq3.w.du, 6.0);
+}
+
+TEST(DualQuaternion, TestMultiplyQuat)
+{
+    Base::DualQuat qq1 = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+    Base::DualQuat qq2 = Base::DualQuat(1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0);
+    Base::DualQuat qq3 = qq1 * qq2;
+    EXPECT_EQ(qq3.x.re, 4.0);
+    EXPECT_EQ(qq3.x.du, 20.0);
+    EXPECT_EQ(qq3.y.re, 8.0);
+    EXPECT_EQ(qq3.y.du, 32.0);
+    EXPECT_EQ(qq3.z.re, 6.0);
+    EXPECT_EQ(qq3.z.du, 26.0);
+    EXPECT_EQ(qq3.w.re, -2.0);
+    EXPECT_EQ(qq3.w.du, -14.0);
+}
+
+TEST(DualQuaternion, TestMultiplyNumber)
+{
+    Base::DualQuat qq1 = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+    Base::DualNumber dn1(1.0, 2.0);
+
+    Base::DualQuat qq4 = qq1 * dn1;
+    EXPECT_EQ(qq4.x.re, 1.0);
+    EXPECT_EQ(qq4.x.du, 7.0);
+    EXPECT_EQ(qq4.y.re, 2.0);
+    EXPECT_EQ(qq4.y.du, 10.0);
+    EXPECT_EQ(qq4.z.re, 3.0);
+    EXPECT_EQ(qq4.z.du, 13.0);
+    EXPECT_EQ(qq4.w.re, 4.0);
+    EXPECT_EQ(qq4.w.du, 16.0);
+
+    Base::DualQuat qq5 = dn1 * qq1;
+    EXPECT_EQ(qq5.x.re, 1.0);
+    EXPECT_EQ(qq5.x.du, 7.0);
+    EXPECT_EQ(qq5.y.re, 2.0);
+    EXPECT_EQ(qq5.y.du, 10.0);
+    EXPECT_EQ(qq5.z.re, 3.0);
+    EXPECT_EQ(qq5.z.du, 13.0);
+    EXPECT_EQ(qq5.w.re, 4.0);
+    EXPECT_EQ(qq5.w.du, 16.0);
+}
+
+TEST(DualQuaternion, TestMultiplyScalar)
+{
+    Base::DualQuat qq1 = Base::DualQuat(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
+
+    Base::DualQuat qq4 = qq1 * 2.0;
+    EXPECT_EQ(qq4.x.re, 2.0);
+    EXPECT_EQ(qq4.x.du, 10.0);
+    EXPECT_EQ(qq4.y.re, 4.0);
+    EXPECT_EQ(qq4.y.du, 12.0);
+    EXPECT_EQ(qq4.z.re, 6.0);
+    EXPECT_EQ(qq4.z.du, 14.0);
+    EXPECT_EQ(qq4.w.re, 8.0);
+    EXPECT_EQ(qq4.w.du, 16.0);
+
+    Base::DualQuat qq5 = 2.0 * qq1;
+    EXPECT_EQ(qq5.x.re, 2.0);
+    EXPECT_EQ(qq5.x.du, 10.0);
+    EXPECT_EQ(qq5.y.re, 4.0);
+    EXPECT_EQ(qq5.y.du, 12.0);
+    EXPECT_EQ(qq5.z.re, 6.0);
+    EXPECT_EQ(qq5.z.du, 14.0);
+    EXPECT_EQ(qq5.w.re, 8.0);
+    EXPECT_EQ(qq5.w.du, 16.0);
+}
+
+TEST(DualQuaternion, TestPow)
+{
+    const double epsilon = 1e-12;
+    Base::DualQuat qq1 = Base::DualQuat(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
+    Base::DualQuat qq2 = qq1.pow(2.0);
+    EXPECT_NEAR(qq2.x.re, 0.0, epsilon);
+    EXPECT_NEAR(qq2.x.du, 0.0, epsilon);
+    EXPECT_NEAR(qq2.y.re, 0.0, epsilon);
+    EXPECT_NEAR(qq2.y.du, 0.0, epsilon);
+    EXPECT_NEAR(qq2.z.re, 0.0, epsilon);
+    EXPECT_NEAR(qq2.z.du, 0.0, epsilon);
+    EXPECT_NEAR(qq2.w.re, -1.0, epsilon);
+    EXPECT_NEAR(qq2.w.du, 0.0, epsilon);
+}
diff --git a/tests/src/Base/Handle.cpp b/tests/src/Base/Handle.cpp
new file mode 100644
index 0000000000..09563d2e80
--- /dev/null
+++ b/tests/src/Base/Handle.cpp
@@ -0,0 +1,72 @@
+#include "gtest/gtest.h"
+#include <Base/Handle.h>
+
+class Data: public Base::Handled
+{
+    int myValue {};
+
+public:
+    int getValue() const
+    {
+        return myValue;
+    }
+    void setValue(int val)
+    {
+        myValue = val;
+    }
+};
+
+TEST(Reference, TestNull)
+{
+    Base::Reference<Data> data;
+    EXPECT_EQ(data.getRefCount(), 0);
+}
+
+TEST(Reference, TestConstructor)
+{
+    Base::Reference<Data> data(new Data);
+    EXPECT_EQ(data.getRefCount(), 1);
+}
+
+TEST(Reference, TestCopy)
+{
+    Base::Reference<Data> data(new Data);
+    Base::Reference<Data> copy(data);
+    EXPECT_EQ(data.getRefCount(), 2);
+    EXPECT_EQ(copy.getRefCount(), 2);
+    EXPECT_EQ(data, copy);
+    EXPECT_EQ(data.isValid(), true);
+    EXPECT_EQ(copy.isValid(), true);
+    EXPECT_EQ(data.isNull(), false);
+    EXPECT_EQ(copy.isNull(), false);
+}
+
+TEST(Reference, TestAssignRaw)
+{
+    Base::Reference<Data> data = new Data();
+    EXPECT_EQ(data->getValue(), 0);
+    EXPECT_EQ(data.getRefCount(), 1);
+}
+
+TEST(Reference, TestAssignRef)
+{
+    Base::Reference<Data> data = new Data();
+    Base::Reference<Data> copy;
+    copy = data;
+    EXPECT_EQ(data.getRefCount(), 2);
+    EXPECT_EQ(copy.getRefCount(), 2);
+    EXPECT_EQ(data, copy);
+    EXPECT_EQ(data.isValid(), true);
+    EXPECT_EQ(copy.isValid(), true);
+    EXPECT_EQ(data.isNull(), false);
+    EXPECT_EQ(copy.isNull(), false);
+}
+
+TEST(Reference, TestRefHandle)
+{
+    Base::Reference<Data> data = new Data();
+    data->ref();
+    EXPECT_EQ(data.getRefCount(), 2);
+    data->unref();
+    EXPECT_EQ(data.getRefCount(), 1);
+}
diff --git a/tests/src/Base/Matrix.cpp b/tests/src/Base/Matrix.cpp
index 3797143737..96474dfd76 100644
--- a/tests/src/Base/Matrix.cpp
+++ b/tests/src/Base/Matrix.cpp
@@ -2,6 +2,7 @@
 #include <Base/Matrix.h>
 
 // NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
+// clang-format off
 TEST(Matrix, TestShearing)
 {
     Base::Matrix4D mat;
@@ -97,8 +98,26 @@ TEST(Matrix, TestTrace)
 TEST(Matrix, TestColRow)
 {
     Base::Matrix4D mat;
+    EXPECT_EQ(mat.getCol(0), Base::Vector3d(1, 0, 0));
     EXPECT_EQ(mat.getCol(1), Base::Vector3d(0, 1, 0));
     EXPECT_EQ(mat.getCol(2), Base::Vector3d(0, 0, 1));
+    EXPECT_EQ(mat.getRow(0), Base::Vector3d(1, 0, 0));
+    EXPECT_EQ(mat.getRow(1), Base::Vector3d(0, 1, 0));
+    EXPECT_EQ(mat.getRow(2), Base::Vector3d(0, 0, 1));
+}
+
+TEST(Matrix, TestColRowMisc)
+{
+    Base::Matrix4D mat{1.0, 2.0, 3.0, 0.0,
+                       3.0, 1.0, 2.0, 2.0,
+                       2.0, 3.0, 1.0, 1.0,
+                       0.0, 0.0, 0.0, 1.0};
+    EXPECT_EQ(mat.getCol(0), Base::Vector3d(1.0, 3.0, 2.0));
+    EXPECT_EQ(mat.getCol(1), Base::Vector3d(2.0, 1.0, 3.0));
+    EXPECT_EQ(mat.getCol(2), Base::Vector3d(3.0, 2.0, 1.0));
+    EXPECT_EQ(mat.getRow(0), Base::Vector3d(1.0, 2.0, 3.0));
+    EXPECT_EQ(mat.getRow(1), Base::Vector3d(3.0, 1.0, 2.0));
+    EXPECT_EQ(mat.getRow(2), Base::Vector3d(2.0, 3.0, 1.0));
 }
 
 TEST(Matrix, TestUnity)
@@ -121,4 +140,128 @@ TEST(Matrix, TestNull)
     mat.nullify();
     EXPECT_EQ(mat.isNull(), true);
 }
+
+TEST(Matrix, TestMultVec)
+{
+    Base::Matrix4D mat{1.0, 2.0, 3.0, 0.0,
+                       2.0, 3.0, 1.0, 1.0,
+                       3.0, 1.0, 2.0, 2.0,
+                       0.0, 0.0, 0.0, 1.0};
+    Base::Vector3d vec1{1,1,3};
+    vec1 = mat * vec1;
+    EXPECT_EQ(vec1, Base::Vector3d(12.0, 9.0, 12.0));
+
+    Base::Vector3d vec2 {1, 1, 1};
+    mat.multVec(vec2, vec2);
+    EXPECT_EQ(vec2, Base::Vector3d(6.0, 7.0, 8.0));
+}
+
+TEST(Matrix, TestMult)
+{
+    Base::Matrix4D mat1{1.0, 2.0, 3.0, 0.0,
+                        2.0, 3.0, 1.0, 1.0,
+                        3.0, 1.0, 2.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat2{1.0, 2.0, 3.0, 0.0,
+                        3.0, 1.0, 2.0, 1.0,
+                        2.0, 3.0, 1.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat3 = mat1 * mat2;
+    Base::Matrix4D mat4{13.0, 13.0, 10.0, 8.0,
+                        13.0, 10.0, 13.0, 6.0,
+                        10.0, 13.0, 13.0, 7.0,
+                        0.0, 0.0, 0.0, 1.0};
+    EXPECT_EQ(mat3, mat4);
+}
+
+TEST(Matrix, TestMultAssign)
+{
+    Base::Matrix4D mat1{1.0, 2.0, 3.0, 0.0,
+                        2.0, 3.0, 1.0, 1.0,
+                        3.0, 1.0, 2.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat2{1.0, 2.0, 3.0, 0.0,
+                        3.0, 1.0, 2.0, 1.0,
+                        2.0, 3.0, 1.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    mat1 *= mat2;
+    Base::Matrix4D mat4{13.0, 13.0, 10.0, 8.0,
+                        13.0, 10.0, 13.0, 6.0,
+                        10.0, 13.0, 13.0, 7.0,
+                        0.0, 0.0, 0.0, 1.0};
+    EXPECT_EQ(mat1, mat4);
+}
+
+TEST(Matrix, TestAdd)
+{
+    Base::Matrix4D mat1{1.0, 2.0, 3.0, 0.0,
+                        2.0, 3.0, 1.0, 1.0,
+                        3.0, 1.0, 2.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat2{1.0, 2.0, 3.0, 0.0,
+                        3.0, 1.0, 2.0, 1.0,
+                        2.0, 3.0, 1.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat3 = mat1 + mat2;
+    Base::Matrix4D mat4{2.0, 4.0, 6.0, 0.0,
+                        5.0, 4.0, 3.0, 2.0,
+                        5.0, 4.0, 3.0, 4.0,
+                        0.0, 0.0, 0.0, 2.0};
+    EXPECT_EQ(mat3, mat4);
+}
+
+TEST(Matrix, TestAddAssign)
+{
+    Base::Matrix4D mat1{1.0, 2.0, 3.0, 0.0,
+                        2.0, 3.0, 1.0, 1.0,
+                        3.0, 1.0, 2.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat2{1.0, 2.0, 3.0, 0.0,
+                        3.0, 1.0, 2.0, 1.0,
+                        2.0, 3.0, 1.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    mat1 += mat2;
+    Base::Matrix4D mat4{2.0, 4.0, 6.0, 0.0,
+                        5.0, 4.0, 3.0, 2.0,
+                        5.0, 4.0, 3.0, 4.0,
+                        0.0, 0.0, 0.0, 2.0};
+    EXPECT_EQ(mat1, mat4);
+}
+
+TEST(Matrix, TestSub)
+{
+    Base::Matrix4D mat1{1.0, 2.0, 3.0, 0.0,
+                        2.0, 3.0, 1.0, 1.0,
+                        3.0, 1.0, 2.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat2{1.0, 2.0, 3.0, 0.0,
+                        3.0, 1.0, 2.0, 1.0,
+                        2.0, 3.0, 1.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat3 = mat1 - mat2;
+    Base::Matrix4D mat4{0.0, 0.0, 0.0, 0.0,
+                        -1.0, 2.0, -1.0, 0.0,
+                        1.0, -2.0, 1.0, 0.0,
+                        0.0, 0.0, 0.0, 0.0};
+    EXPECT_EQ(mat3, mat4);
+}
+
+TEST(Matrix, TestSubAssign)
+{
+    Base::Matrix4D mat1{1.0, 2.0, 3.0, 0.0,
+                        2.0, 3.0, 1.0, 1.0,
+                        3.0, 1.0, 2.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    Base::Matrix4D mat2{1.0, 2.0, 3.0, 0.0,
+                        3.0, 1.0, 2.0, 1.0,
+                        2.0, 3.0, 1.0, 2.0,
+                        0.0, 0.0, 0.0, 1.0};
+    mat1 -= mat2;
+    Base::Matrix4D mat4{0.0, 0.0, 0.0, 0.0,
+                        -1.0, 2.0, -1.0, 0.0,
+                        1.0, -2.0, 1.0, 0.0,
+                        0.0, 0.0, 0.0, 0.0};
+    EXPECT_EQ(mat1, mat4);
+}
+// clang-format on
 // NOLINTEND(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
diff --git a/tests/src/Base/Placement.cpp b/tests/src/Base/Placement.cpp
new file mode 100644
index 0000000000..603eeb3a22
--- /dev/null
+++ b/tests/src/Base/Placement.cpp
@@ -0,0 +1,215 @@
+#include "gtest/gtest.h"
+#include <Base/DualQuaternion.h>
+#include <Base/Matrix.h>
+#include <Base/Placement.h>
+#include <Base/Tools.h>
+
+static const double epsilon = 1e-9;
+
+TEST(Placement, TestDefault)
+{
+    Base::Placement plm;
+    EXPECT_EQ(plm.getPosition().IsNull(), true);
+    EXPECT_EQ(plm.getRotation().isNull(), false);
+    EXPECT_EQ(plm.getRotation().isIdentity(), true);
+}
+
+TEST(Placement, TestPosRot)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 1, 2, 2);
+    Base::Placement plm(pos, rot);
+    EXPECT_EQ(plm.getPosition(), pos);
+    EXPECT_EQ(plm.getRotation(), rot);
+}
+
+TEST(Placement, TestPosRotCnt)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 0, 0, 0);
+    Base::Vector3d cnt(4, 5, 6);
+    Base::Placement plm(pos, rot, cnt);
+
+    EXPECT_EQ(plm.getPosition(), Base::Vector3d(1, 12, 15));
+    EXPECT_EQ(plm.getRotation(), rot);
+}
+
+TEST(Placement, TestMatrix)
+{
+    Base::Matrix4D mat;
+    mat.rotX(Base::toRadians(90.0));
+    mat.rotY(Base::toRadians(90.0));
+    mat.rotZ(Base::toRadians(90.0));
+    mat.setCol(3, Base::Vector3d(1, 2, 3));
+    Base::Placement plm(mat);
+    EXPECT_EQ(plm.getPosition(), Base::Vector3d(1, 2, 3));
+    Base::Vector3d axis;
+    double angle {};
+    plm.getRotation().getValue(axis, angle);
+    EXPECT_EQ(angle, Base::toRadians(90.0));
+    EXPECT_EQ(axis.IsEqual(Base::Vector3d(0, 1, 0), 0.001), true);
+}
+
+TEST(Placement, TestIdentity)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 0, 0, 0);
+    Base::Vector3d cnt(4, 5, 6);
+    Base::Placement plm(pos, rot, cnt);
+    Base::Placement mult = plm * plm.inverse();
+    EXPECT_EQ(mult.isIdentity(), true);
+}
+
+TEST(Placement, TestInvert)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 0, 0, 0);
+    Base::Vector3d cnt(4, 5, 6);
+    Base::Placement plm(pos, rot, cnt);
+    plm.invert();
+    EXPECT_EQ(plm.getPosition(), Base::Vector3d(-1, 12, 15));
+    EXPECT_EQ(plm.getRotation().isIdentity(), false);
+    EXPECT_EQ(plm.getRotation(), rot);
+}
+
+TEST(Placement, TestMove)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 0, 0, 0);
+    Base::Vector3d cnt(4, 5, 6);
+    Base::Placement plm(pos, rot, cnt);
+    plm.move(Base::Vector3d(-1, -12, -15));
+    EXPECT_EQ(plm.getPosition().IsNull(), true);
+}
+
+TEST(Placement, TestSame)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 0, 0, 0);
+    Base::Vector3d cnt(4, 5, 6);
+    Base::Placement plm(pos, rot, cnt);
+    EXPECT_EQ(plm.isSame(plm), true);
+    EXPECT_EQ(plm.isSame(plm, 0.001), true);
+    EXPECT_EQ(plm == plm, true);
+
+    Base::Placement plm2(plm * plm);
+    EXPECT_EQ(plm2.isSame(plm), false);
+    EXPECT_EQ(plm2.isSame(plm, 0.001), false);
+    EXPECT_EQ(plm2 == plm, false);
+}
+
+TEST(Placement, TestMultiply)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 0, 0, 0);
+    Base::Vector3d cnt(4, 5, 6);
+    Base::Placement plm(pos, rot, cnt);
+
+    Base::Placement plm2(plm * plm);
+    EXPECT_EQ(plm2.getRotation().isIdentity(), true);
+}
+
+TEST(Placement, TestMultRight)
+{
+    Base::Vector3d pos1(1, 2, 3);
+    Base::Rotation rot1(1, 0, 0, 0);
+    Base::Placement plm1(pos1, rot1);
+
+    Base::Vector3d pos2(3, 2, 1);
+    Base::Rotation rot2(0, 1, 0, 0);
+    Base::Placement plm2(pos2, rot2);
+
+    plm1.multRight(plm2);
+    EXPECT_EQ(plm1.getRotation(), Base::Rotation(0, 0, 1, 0));
+    EXPECT_EQ(plm1.getPosition(), Base::Vector3d(4, 0, 2));
+}
+
+TEST(Placement, TestMultLeft)
+{
+    Base::Vector3d pos1(1, 2, 3);
+    Base::Rotation rot1(1, 0, 0, 0);
+    Base::Placement plm1(pos1, rot1);
+
+    Base::Vector3d pos2(3, 2, 1);
+    Base::Rotation rot2(0, 1, 0, 0);
+    Base::Placement plm2(pos2, rot2);
+
+    plm1.multLeft(plm2);
+    EXPECT_EQ(plm1.getRotation(), Base::Rotation(0, 0, 1, 0));
+    EXPECT_EQ(plm1.getPosition(), Base::Vector3d(2, 4, -2));
+}
+
+TEST(Placement, TestMultVec)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 0, 0, 0);
+    Base::Placement plm(pos, rot);
+
+    Base::Vector3d vec {1, 1, 1};
+    plm.multVec(vec, vec);
+    EXPECT_EQ(vec, Base::Vector3d(2, 1, 2));
+}
+
+TEST(Placement, TestDualQuat)
+{
+    Base::Vector3d pos(1, 2, 3);
+    Base::Rotation rot(1, 0, 0, 0);
+    Base::Placement plm(pos, rot);
+    Base::DualQuat qq = plm.toDualQuaternion();
+    Base::Placement plm2 = Base::Placement::fromDualQuaternion(qq);
+    EXPECT_EQ(plm.isSame(plm2), true);
+}
+
+TEST(Placement, TestPow)
+{
+    Base::Vector3d axis1, axis2;
+    double angle1 {}, angle2 {};
+
+    Base::Vector3d pos(1, 4, 6);
+    Base::Rotation rot(1, 2, 3, 4);
+    Base::Placement plm(pos, rot);
+    rot.getValue(axis1, angle1);
+
+    Base::Placement plm2 = plm.pow(1.5);
+    plm2.getRotation().getValue(axis2, angle2);
+    EXPECT_DOUBLE_EQ(angle2, 1.5 * angle1);
+    EXPECT_EQ(axis1.IsEqual(axis2, 0.0001), true);
+}
+
+TEST(Placement, TestSlerp)
+{
+    Base::Vector3d pos(1, 4, 6);
+    Base::Rotation rot1(1, 0, 0, 0);
+    Base::Rotation rot2(0, 1, 0, 0);
+    Base::Placement plm1(pos, rot1);
+    Base::Placement plm2(pos, rot2);
+
+    Base::Placement plm3 = Base::Placement::slerp(plm1, plm2, 0.0);
+    EXPECT_EQ(plm3.isSame(plm1), true);
+    Base::Placement plm4 = Base::Placement::slerp(plm1, plm2, 1.0);
+    EXPECT_EQ(plm4.isSame(plm2), true);
+    Base::Placement plm5 = Base::Placement::slerp(plm1, plm1, 0.5);
+    EXPECT_EQ(plm5.isSame(plm1), true);
+    Base::Placement plm6 = Base::Placement::slerp(plm1, plm2, 0.5);
+    EXPECT_EQ(plm6.getRotation().isSame(Base::Rotation(1, 1, 0, 0), epsilon), true);
+    EXPECT_EQ(plm6.getPosition().IsEqual(pos, epsilon), true);
+}
+
+TEST(Placement, TestSclerp)
+{
+    Base::Vector3d pos(1, 4, 6);
+    Base::Rotation rot1(1, 0, 0, 0);
+    Base::Rotation rot2(0, 1, 0, 0);
+    Base::Placement plm1(pos, rot1);
+    Base::Placement plm2(pos, rot2);
+
+    Base::Placement plm3 = Base::Placement::sclerp(plm1, plm2, 0.0);
+    EXPECT_EQ(plm3.isSame(plm1), true);
+    Base::Placement plm4 = Base::Placement::sclerp(plm1, plm2, 1.0);
+    EXPECT_EQ(plm4.isSame(plm2, epsilon), true);
+    Base::Placement plm5 = Base::Placement::sclerp(plm1, plm1, 0.5);
+    EXPECT_EQ(plm5.isSame(plm1), true);
+    Base::Placement plm6 = Base::Placement::sclerp(plm1, plm2, 0.5);
+    EXPECT_EQ(plm6.getRotation().isSame(Base::Rotation(1, 1, 0, 0), epsilon), true);
+    EXPECT_EQ(plm6.getPosition().IsEqual(pos, epsilon), true);
+}
diff --git a/tests/src/Base/TimeInfo.cpp b/tests/src/Base/TimeInfo.cpp
new file mode 100644
index 0000000000..04f4155550
--- /dev/null
+++ b/tests/src/Base/TimeInfo.cpp
@@ -0,0 +1,35 @@
+#include "gtest/gtest.h"
+#include <Base/TimeInfo.h>
+
+TEST(TimeInfo, TestDefault)
+{
+    Base::TimeInfo ti;
+    EXPECT_EQ(ti.isNull(), false);
+}
+
+TEST(TimeInfo, TestNull)
+{
+    Base::TimeInfo ti(Base::TimeInfo::null());
+    EXPECT_EQ(ti.isNull(), true);
+}
+
+TEST(TimeInfo, TestCompare)
+{
+    Base::TimeInfo ti1;
+    Base::TimeInfo ti2;
+    ti2.setTime_t(ti1.getSeconds() + 1);
+    EXPECT_EQ(ti1 == ti1, true);
+    EXPECT_EQ(ti1 != ti2, true);
+    EXPECT_EQ(ti1 < ti2, true);
+    EXPECT_EQ(ti1 > ti2, false);
+    EXPECT_EQ(ti1 <= ti1, true);
+    EXPECT_EQ(ti1 >= ti1, true);
+}
+
+TEST(TimeInfo, TestDiffTime)
+{
+    Base::TimeInfo ti1;
+    Base::TimeInfo ti2;
+    ti2.setTime_t(ti1.getSeconds() + 1);
+    EXPECT_EQ(Base::TimeInfo::diffTimeF(ti1, ti2), 1.0);
+}
diff --git a/tests/src/Base/tst_Tools.cpp b/tests/src/Base/Tools.cpp
similarity index 100%
rename from tests/src/Base/tst_Tools.cpp
rename to tests/src/Base/Tools.cpp
diff --git a/tests/src/Base/Tools2D.cpp b/tests/src/Base/Tools2D.cpp
new file mode 100644
index 0000000000..77839d38e4
--- /dev/null
+++ b/tests/src/Base/Tools2D.cpp
@@ -0,0 +1,87 @@
+#include "gtest/gtest.h"
+#include <Base/Tools2D.h>
+
+class Line2D: public ::testing::Test
+{
+protected:
+    Line2D()
+        : pt1(0.0, 0.0)
+        , pt2(3.0, 4.0)
+    {}
+    void SetUp() override
+    {}
+    void TearDown() override
+    {}
+    Base::Vector2d GetFirst() const
+    {
+        return pt1;
+    }
+    Base::Vector2d GetSecond() const
+    {
+        return pt2;
+    }
+    Base::Line2d GetLine() const
+    {
+        Base::Line2d line(pt1, pt2);
+        return line;
+    }
+
+private:
+    Base::Vector2d pt1, pt2;
+};
+
+TEST_F(Line2D, TestLength)
+{
+    Base::Line2d line(GetLine());
+    EXPECT_DOUBLE_EQ(line.Length(), 5.0);
+}
+
+TEST_F(Line2D, TestPoints)
+{
+    Base::Line2d line(GetLine());
+    EXPECT_EQ(line.clV1, GetFirst());
+    EXPECT_EQ(line.clV2, GetSecond());
+}
+
+TEST_F(Line2D, TestFromPos)
+{
+    Base::Line2d line(GetLine());
+    EXPECT_EQ(line.FromPos(2.5), Base::Vector2d(1.5, 2.0));
+}
+
+TEST_F(Line2D, TestContains)
+{
+    Base::Line2d line(GetLine());
+    EXPECT_EQ(line.Contains(Base::Vector2d(1.5, 2.0)), true);
+}
+
+TEST(Polygon2D, TestDefault)
+{
+    Base::Polygon2d poly;
+    EXPECT_EQ(poly.GetCtVectors(), 0);
+}
+
+TEST(Polygon2D, TestAdd)
+{
+    Base::Polygon2d poly;
+    poly.Add(Base::Vector2d());
+    EXPECT_EQ(poly.GetCtVectors(), 1);
+}
+
+TEST(Polygon2D, TestRemove)
+{
+    Base::Polygon2d poly;
+    poly.Add(Base::Vector2d());
+    EXPECT_EQ(poly.GetCtVectors(), 1);
+    EXPECT_EQ(poly.Delete(1), false);
+    EXPECT_EQ(poly.Delete(0), true);
+    EXPECT_EQ(poly.GetCtVectors(), 0);
+}
+
+TEST(Polygon2D, TestClear)
+{
+    Base::Polygon2d poly;
+    poly.Add(Base::Vector2d());
+    poly.DeleteAll();
+    EXPECT_EQ(poly.GetCtVectors(), 0);
+}
diff --git a/tests/src/Base/Tools3D.cpp b/tests/src/Base/Tools3D.cpp
new file mode 100644
index 0000000000..781323b88c
--- /dev/null
+++ b/tests/src/Base/Tools3D.cpp
@@ -0,0 +1,93 @@
+#include "gtest/gtest.h"
+#include <Base/Tools3D.h>
+
+class Line3D: public ::testing::Test
+{
+protected:
+    Line3D()
+        : pt1(0, 0, 0)
+        , pt2(3, 4, 0)
+    {}
+    void SetUp() override
+    {}
+    void TearDown() override
+    {}
+    Base::Vector3d GetFirst() const
+    {
+        return pt1;
+    }
+    Base::Vector3d GetSecond() const
+    {
+        return pt2;
+    }
+    Base::Line3d GetLine() const
+    {
+        Base::Line3d line(pt1, pt2);
+        return line;
+    }
+
+private:
+    Base::Vector3d pt1, pt2;
+};
+
+TEST_F(Line3D, TestLength)
+{
+    Base::Line3d line(GetLine());
+    EXPECT_DOUBLE_EQ(line.Length(), 5.0);
+}
+
+TEST_F(Line3D, TestSqrLength)
+{
+    Base::Line3d line(GetLine());
+    EXPECT_DOUBLE_EQ(line.SqrLength(), 25.0);
+}
+
+TEST_F(Line3D, TestPoints)
+{
+    Base::Line3d line(GetLine());
+    EXPECT_EQ(line.GetBase(), GetFirst());
+    EXPECT_EQ(line.GetDirection(), GetSecond());
+}
+
+TEST_F(Line3D, TestFromPos)
+{
+    Base::Line3d line(GetLine());
+    EXPECT_EQ(line.FromPos(2.5), Base::Vector3d(1.5, 2, 0));
+}
+
+TEST_F(Line3D, TestContains)
+{
+    Base::Line3d line(GetLine());
+    EXPECT_EQ(line.Contains(Base::Vector3d(1.5, 2, 0)), true);
+}
+
+TEST(Polygon3D, TestDefault)
+{
+    Base::Polygon3d poly;
+    EXPECT_EQ(poly.GetSize(), 0);
+}
+
+TEST(Polygon3D, TestAdd)
+{
+    Base::Polygon3d poly;
+    poly.Add(Base::Vector3d());
+    EXPECT_EQ(poly.GetSize(), 1);
+}
+
+TEST(Polygon3D, TestRemove)
+{
+    Base::Polygon3d poly;
+    poly.Add(Base::Vector3d());
+    EXPECT_EQ(poly.GetSize(), 1);
+    EXPECT_EQ(poly.Remove(1), false);
+    EXPECT_EQ(poly.Remove(0), true);
+    EXPECT_EQ(poly.GetSize(), 0);
+}
+
+TEST(Polygon3D, TestClear)
+{
+    Base::Polygon3d poly;
+    poly.Add(Base::Vector3d());
+    poly.Clear();
+    EXPECT_EQ(poly.GetSize(), 0);
+}
diff --git a/tests/src/Base/Vector3D.cpp b/tests/src/Base/Vector3D.cpp
new file mode 100644
index 0000000000..4719bc26b0
--- /dev/null
+++ b/tests/src/Base/Vector3D.cpp
@@ -0,0 +1,263 @@
+#include "gtest/gtest.h"
+#include <Base/Vector3D.h>
+
+TEST(Vector, TestDefault)
+{
+    Base::Vector3d vec;
+    EXPECT_EQ(vec.x, 0.0);
+    EXPECT_EQ(vec.y, 0.0);
+    EXPECT_EQ(vec.z, 0.0);
+}
+
+TEST(Vector, TestDefault2)
+{
+    Base::Vector3d vec(1.0, 2.0, 3.0);
+    EXPECT_EQ(vec.x, 1.0);
+    EXPECT_EQ(vec.y, 2.0);
+    EXPECT_EQ(vec.z, 3.0);
+}
+
+TEST(Vector, TestCopy)
+{
+    Base::Vector3d vec(1.0, 2.0, 3.0);
+    Base::Vector3d copy(vec);
+    EXPECT_EQ(copy.x, 1.0);
+    EXPECT_EQ(copy.y, 2.0);
+    EXPECT_EQ(copy.z, 3.0);
+}
+
+TEST(Vector, TestMove)
+{
+    Base::Vector3d vec(1.0, 2.0, 3.0);
+    Base::Vector3d copy(std::move(vec));
+    EXPECT_EQ(copy.x, 1.0);
+    EXPECT_EQ(copy.y, 2.0);
+    EXPECT_EQ(copy.z, 3.0);
+}
+
+TEST(Vector, TestNull)
+{
+    Base::Vector3d vec(1.0, 2.0, 3.0);
+    EXPECT_EQ(vec.IsNull(), false);
+    EXPECT_EQ(Base::Vector3d().IsNull(), true);
+}
+
+TEST(Vector, TestEqual)
+{
+    Base::Vector3d vec(1.0, 2.0, 3.0);
+    EXPECT_EQ(vec.IsEqual(vec, 0), true);
+    EXPECT_EQ(Base::Vector3d().IsEqual(vec, 0), false);
+}
+
+TEST(Vector, TestIndex)
+{
+    Base::Vector3d vec(1.0, 2.0, 3.0);
+    EXPECT_EQ(vec[0], 1.0);
+    EXPECT_EQ(vec[1], 2.0);
+    EXPECT_EQ(vec[2], 3.0);
+    vec[0] = 4.0;
+    EXPECT_EQ(vec[0], 4.0);
+}
+
+TEST(Vector, TestPlus)
+{
+    Base::Vector3d vec = Base::Vector3d(1, 2, 3) + Base::Vector3d(4, 3, 1);
+    EXPECT_EQ(vec.x, 5.0);
+    EXPECT_EQ(vec.y, 5.0);
+    EXPECT_EQ(vec.z, 4.0);
+}
+
+TEST(Vector, TestPlusAssign)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec += Base::Vector3d(4, 3, 1);
+    EXPECT_EQ(vec.x, 5.0);
+    EXPECT_EQ(vec.y, 5.0);
+    EXPECT_EQ(vec.z, 4.0);
+}
+
+TEST(Vector, TestMinus)
+{
+    Base::Vector3d vec = Base::Vector3d(1, 2, 3) - Base::Vector3d(4, 3, 1);
+    EXPECT_EQ(vec.x, -3.0);
+    EXPECT_EQ(vec.y, -1.0);
+    EXPECT_EQ(vec.z, 2.0);
+}
+
+TEST(Vector, TestMinusAssign)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec -= Base::Vector3d(4, 3, 1);
+    EXPECT_EQ(vec.x, -3.0);
+    EXPECT_EQ(vec.y, -1.0);
+    EXPECT_EQ(vec.z, 2.0);
+}
+
+TEST(Vector, TestNegative)
+{
+    Base::Vector3d vec = -Base::Vector3d(4, 3, 1);
+    EXPECT_EQ(vec.x, -4.0);
+    EXPECT_EQ(vec.y, -3.0);
+    EXPECT_EQ(vec.z, -1.0);
+}
+
+TEST(Vector, TestScale)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec = vec * 2.0;
+    EXPECT_EQ(vec.x, 2.0);
+    EXPECT_EQ(vec.y, 4.0);
+    EXPECT_EQ(vec.z, 6.0);
+}
+
+TEST(Vector, TestScaleAssign)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec *= 2.0;
+    EXPECT_EQ(vec.x, 2.0);
+    EXPECT_EQ(vec.y, 4.0);
+    EXPECT_EQ(vec.z, 6.0);
+}
+
+TEST(Vector, TestDivScale)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec = vec / 2.0;
+    EXPECT_EQ(vec.x, 0.5);
+    EXPECT_EQ(vec.y, 1.0);
+    EXPECT_EQ(vec.z, 1.5);
+}
+
+TEST(Vector, TestDivScaleAssign)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec /= 2.0;
+    EXPECT_EQ(vec.x, 0.5);
+    EXPECT_EQ(vec.y, 1.0);
+    EXPECT_EQ(vec.z, 1.5);
+}
+
+TEST(Vector, TestScaleXYZ)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec.Scale(1, 2, 3);
+    EXPECT_EQ(vec.x, 1.0);
+    EXPECT_EQ(vec.y, 4.0);
+    EXPECT_EQ(vec.z, 9.0);
+}
+
+TEST(Vector, TestMoveXYZ)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec.Move(1, 2, 3);
+    EXPECT_EQ(vec.x, 2.0);
+    EXPECT_EQ(vec.y, 4.0);
+    EXPECT_EQ(vec.z, 6.0);
+}
+
+TEST(Vector, TestCopyAssign)
+{
+    Base::Vector3d vec;
+    Base::Vector3d copy(1, 2, 3);
+    vec = copy;
+    EXPECT_EQ(vec.x, 1.0);
+    EXPECT_EQ(vec.y, 2.0);
+    EXPECT_EQ(vec.z, 3.0);
+}
+
+TEST(Vector, TestMoveAssign)
+{
+    Base::Vector3d vec;
+    Base::Vector3d copy(1, 2, 3);
+    vec = std::move(copy);
+    EXPECT_EQ(vec.x, 1.0);
+    EXPECT_EQ(vec.y, 2.0);
+    EXPECT_EQ(vec.z, 3.0);
+}
+
+TEST(Vector, TestScalar)
+{
+    Base::Vector3d vec1(1, 2, 3);
+    Base::Vector3d vec2(3, 2, 1);
+    double dot1 = vec1 * vec2;
+    double dot2 = vec2.Dot(vec1);
+    EXPECT_EQ(dot1, 10.0);
+    EXPECT_EQ(dot2, 10.0);
+}
+
+TEST(Vector, TestCross)
+{
+    Base::Vector3d vec1(1, 2, 3);
+    Base::Vector3d vec2(3, 2, 1);
+    Base::Vector3d cross1 = vec1 % vec2;
+    Base::Vector3d cross2 = vec2.Cross(vec1);
+    EXPECT_EQ(cross1.x, -4.0);
+    EXPECT_EQ(cross1.y, 8.0);
+    EXPECT_EQ(cross1.z, -4.0);
+    EXPECT_EQ(cross2.x, 4.0);
+    EXPECT_EQ(cross2.y, -8.0);
+    EXPECT_EQ(cross2.z, 4.0);
+}
+
+TEST(Vector, TestCompare)
+{
+    Base::Vector3d vec1(1, 2, 3);
+    Base::Vector3d vec2(1, 2, 1);
+    EXPECT_EQ(vec1 == vec2, false);
+    EXPECT_EQ(vec1 != vec2, true);
+}
+
+TEST(Vector, TestNormalize)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec.Normalize();
+    EXPECT_EQ(vec.Length(), 1.0);
+}
+
+TEST(Vector, TestCSTransform)
+{
+    Base::Vector3d vec(1, 2, 3);
+    vec.TransformToCoordinateSystem(Base::Vector3d(1, 1, 1),
+                                    Base::Vector3d(0, 1, 0),
+                                    Base::Vector3d(1, 0, 0));
+    EXPECT_EQ(vec.x, 1);
+    EXPECT_EQ(vec.y, 0);
+    EXPECT_EQ(vec.z, -2);
+}
+
+TEST(Vector, TestLineSegment)
+{
+    Base::Vector3d vec(1, 2, 3);
+    EXPECT_EQ(vec.IsOnLineSegment(Base::Vector3d(), Base::Vector3d(2, 4, 6)), true);
+}
+
+TEST(Vector, TestDistanceLineSegment)
+{
+    Base::Vector3d vec(1, 2, 3);
+    EXPECT_EQ(vec.DistanceToLineSegment(Base::Vector3d(), Base::Vector3d(2, 4, 6)).Length(), 0.0);
+}
+
+TEST(Vector, TestProjectToPlane)
+{
+    Base::Vector3d vec(1, 2, 3);
+    Base::Vector3d proj;
+    vec.ProjectToPlane(Base::Vector3d(1, 1, 1), Base::Vector3d(0, 0, 1), proj);
+    EXPECT_EQ(proj.x, 1);
+    EXPECT_EQ(proj.y, 2);
+    EXPECT_EQ(proj.z, 1);
+}
+
+TEST(Vector, TestDistanceToPlane)
+{
+    Base::Vector3d vec(1, 2, 3);
+    double dist = vec.DistanceToPlane(Base::Vector3d(1, 1, 1), Base::Vector3d(0, 0, 1));
+    EXPECT_EQ(dist, 2);
+}
+
+TEST(Vector, TestAngle)
+{
+    Base::Vector3d vec1(0, 0, 0.000001);
+    Base::Vector3d vec2(0, 0.000001, 0);
+    double angle = vec1.GetAngle(vec2);
+    EXPECT_EQ(angle, Base::float_traits<double>::pi() / 2);
+}
diff --git a/tests/src/Base/ViewProj.cpp b/tests/src/Base/ViewProj.cpp
new file mode 100644
index 0000000000..6b1667f236
--- /dev/null
+++ b/tests/src/Base/ViewProj.cpp
@@ -0,0 +1,23 @@
+#include "gtest/gtest.h"
+#include <Base/Placement.h>
+#include <Base/ViewProj.h>
+
+TEST(ViewProj, TestViewProjMatrix)
+{
+    Base::Matrix4D mat;
+    Base::ViewProjMatrix proj(mat);
+
+    Base::Vector3d vec(1, 2, 3);
+    EXPECT_EQ(proj(vec), Base::Vector3d(1, 1.5, 2));
+    EXPECT_EQ(proj.inverse(Base::Vector3d(1, 1.5, 2)), vec);
+}
+
+TEST(ViewProj, TestViewOrthoProjMatrix)
+{
+    Base::Matrix4D mat;
+    Base::ViewOrthoProjMatrix proj(mat);
+
+    Base::Vector3d vec(1, 2, 3);
+    EXPECT_EQ(proj(vec), vec);
+    EXPECT_EQ(proj.inverse(vec), vec);
+}