kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Test: add more unit tests

Browse Source
This commit is contained in:
wmayer
2023-08-26 11:51:02 +02:00
committed by wwmayer
parent 423cc42ac8
commit d623e37e5e
19 changed files with 1826 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/Base/BoundBox.h
View File

@@ -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())

14
src/Base/DualQuaternion.h
View File

@@ -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

1
tests/src/App/CMakeLists.txt
View File

@@ -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
)

15
tests/src/App/Property.cpp Normal file
View File

@@ -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");
}

69
tests/src/Base/Axis.cpp Normal file
View File

@@ -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));
}

269
tests/src/Base/BoundBox.cpp Normal file
View File

@@ -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-*)

14
tests/src/Base/CMakeLists.txt
View File

@@ -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)

150
tests/src/Base/CoordinateSystem.cpp Normal file
View File

@@ -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

103
tests/src/Base/DualNumber.cpp Normal file
View File

@@ -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);
}

266
tests/src/Base/DualQuaternion.cpp Normal file
View File

@@ -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);
}

72
tests/src/Base/Handle.cpp Normal file
View File

@@ -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);
}

143
tests/src/Base/Matrix.cpp
View File

@@ -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)

215
tests/src/Base/Placement.cpp Normal file
View File

@@ -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);
}

35
tests/src/Base/TimeInfo.cpp Normal file
View File

@@ -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);
}

0
tests/src/Base/tst_Tools.cpp → tests/src/Base/Tools.cpp
View File

87
tests/src/Base/Tools2D.cpp Normal file
View File

@@ -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);
}

93
tests/src/Base/Tools3D.cpp Normal file
View File

@@ -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);
}

263
tests/src/Base/Vector3D.cpp Normal file
View File

@@ -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);
}

23
tests/src/Base/ViewProj.cpp Normal file
View File

@@ -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);
}