summaryrefslogtreecommitdiffstats
path: root/test/unit
diff options
context:
space:
mode:
Diffstat (limited to 'test/unit')
-rw-r--r--test/unit/CMakeLists.txt24
-rw-r--r--test/unit/common/CMakeLists.txt16
-rw-r--r--test/unit/common/colobot.ini15
-rw-r--r--test/unit/common/image_test.cpp57
-rw-r--r--test/unit/common/profile_test.cpp43
-rw-r--r--test/unit/main.cpp24
-rw-r--r--test/unit/math/gendata.m86
-rw-r--r--test/unit/math/geometry_test.cpp352
-rw-r--r--test/unit/math/matrix_test.cpp314
-rw-r--r--test/unit/math/vector_test.cpp74
-rw-r--r--test/unit/ui/CMakeLists.txt29
-rw-r--r--test/unit/ui/edit_test.cpp74
-rw-r--r--test/unit/ui/mocks/text_mock.h21
-rw-r--r--test/unit/ui/stubs/app_stub.cpp26
-rw-r--r--test/unit/ui/stubs/engine_stub.cpp79
-rw-r--r--test/unit/ui/stubs/particle_stub.cpp205
-rw-r--r--test/unit/ui/stubs/restext_stub.cpp12
-rw-r--r--test/unit/ui/stubs/robotmain_stub.cpp17
18 files changed, 1468 insertions, 0 deletions
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
new file mode 100644
index 0000000..f6a1d75
--- /dev/null
+++ b/test/unit/CMakeLists.txt
@@ -0,0 +1,24 @@
+set(SRC_DIR ${colobot_SOURCE_DIR}/src)
+
+include_directories(
+${SRC_DIR}
+${GTEST_INCLUDE_DIR}
+math
+common
+)
+
+set(UT_SOURCES
+main.cpp
+math/geometry_test.cpp
+math/matrix_test.cpp
+math/vector_test.cpp
+)
+
+add_executable(colobot_ut ${UT_SOURCES})
+target_link_libraries(colobot_ut gtest)
+
+add_test(colobot_ut ./colobot_ut)
+
+# TODO: change the unit cases to independent automated tests to be included in colobot_ut
+add_subdirectory(common)
+add_subdirectory(ui)
diff --git a/test/unit/common/CMakeLists.txt b/test/unit/common/CMakeLists.txt
new file mode 100644
index 0000000..a34c708
--- /dev/null
+++ b/test/unit/common/CMakeLists.txt
@@ -0,0 +1,16 @@
+set(SRC_DIR ${colobot_SOURCE_DIR}/src)
+
+include_directories(
+${SRC_DIR}
+${GTEST_INCLUDE_DIR}
+)
+
+add_executable(image_test ${SRC_DIR}/common/image.cpp image_test.cpp)
+target_link_libraries(image_test ${SDL_LIBRARY} ${SDLIMAGE_LIBRARY} ${PNG_LIBRARIES})
+
+file(COPY colobot.ini DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+add_executable(profile_test ${SRC_DIR}/common/profile.cpp ${SRC_DIR}/common/logger.cpp profile_test.cpp)
+target_link_libraries(profile_test gtest ${Boost_LIBRARIES})
+
+add_test(profile_test ./profile_test)
diff --git a/test/unit/common/colobot.ini b/test/unit/common/colobot.ini
new file mode 100644
index 0000000..2ca37ee
--- /dev/null
+++ b/test/unit/common/colobot.ini
@@ -0,0 +1,15 @@
+[test_float]
+float_value=1.5
+
+[test_string]
+string_value=Hello world
+
+[test_int]
+int_value=42
+
+[test_multi]
+entry1=1
+entry2=2
+entry3=3
+entry4=4
+entry5=5
diff --git a/test/unit/common/image_test.cpp b/test/unit/common/image_test.cpp
new file mode 100644
index 0000000..2a8d5e4
--- /dev/null
+++ b/test/unit/common/image_test.cpp
@@ -0,0 +1,57 @@
+#include "common/image.h"
+
+#include <SDL/SDL.h>
+#include <stdio.h>
+
+/* For now, just a simple test: loading a file from image
+ * and saving it to another in PNG. */
+
+int main(int argc, char *argv[])
+{
+ if (argc != 3)
+ {
+ printf("Usage: %s in_image out_image\n", argv[0]);
+ return 0;
+ }
+
+ CImage image;
+
+ if (! image.Load(argv[1]))
+ {
+ std::string err = image.GetError();
+ printf("Error loading '%s': %s\n", argv[1], err.c_str());
+ return 1;
+ }
+ Gfx::Color color;
+ std::string str;
+
+ color = image.GetPixel(Math::IntPoint(0, 0));
+ str = color.ToString();
+ printf("pixel @ (0,0): %s\n", str.c_str());
+
+ color = image.GetPixel(Math::IntPoint(0, 1));
+ str = color.ToString();
+ printf("pixel @ (0,1): %s\n", str.c_str());
+
+ color = image.GetPixel(Math::IntPoint(1, 0));
+ str = color.ToString();
+ printf("pixel @ (1,0): %s\n", str.c_str());
+
+ color = image.GetPixel(Math::IntPoint(1, 1));
+ str = color.ToString();
+ printf("pixel @ (1,1): %s\n", str.c_str());
+
+ image.SetPixel(Math::IntPoint(0, 0), Gfx::Color(0.1f, 0.2f, 0.3f, 0.0f));
+ image.SetPixel(Math::IntPoint(1, 0), Gfx::Color(0.3f, 0.2f, 0.1f, 1.0f));
+ image.SetPixel(Math::IntPoint(0, 1), Gfx::Color(1.0f, 1.0f, 1.0f, 1.0f));
+ image.SetPixel(Math::IntPoint(1, 1), Gfx::Color(0.0f, 0.0f, 0.0f, 1.0f));
+
+ if (! image.SavePNG(argv[2]))
+ {
+ std::string err = image.GetError();
+ printf("Error saving PNG '%s': %s\n", argv[2], err.c_str());
+ return 2;
+ }
+
+ return 0;
+}
diff --git a/test/unit/common/profile_test.cpp b/test/unit/common/profile_test.cpp
new file mode 100644
index 0000000..e7b64d5
--- /dev/null
+++ b/test/unit/common/profile_test.cpp
@@ -0,0 +1,43 @@
+#include "common/profile.h"
+#include "common/logger.h"
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <gtest/gtest.h>
+
+
+class CProfileTest : public testing::Test
+{
+protected:
+ CLogger m_logger;
+ CProfile m_profile;
+
+};
+
+TEST_F(CProfileTest, ReadTest)
+{
+ ASSERT_TRUE(m_profile.InitCurrentDirectory()); // load colobot.ini file
+
+ std::string result;
+ ASSERT_TRUE(m_profile.GetLocalProfileString("test_string", "string_value", result));
+ ASSERT_STREQ("Hello world", result.c_str());
+
+ int int_value;
+ ASSERT_TRUE(m_profile.GetLocalProfileInt("test_int", "int_value", int_value));
+ ASSERT_EQ(42, int_value);
+
+ float float_value;
+ ASSERT_TRUE(m_profile.GetLocalProfileFloat("test_float", "float_value", float_value));
+ ASSERT_FLOAT_EQ(1.5, float_value);
+
+ std::vector<std::string> list;
+ list = m_profile.GetLocalProfileSection("test_multi", "entry");
+ ASSERT_EQ(5u, list.size());
+}
+
+int main(int argc, char *argv[])
+{
+ ::testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
diff --git a/test/unit/main.cpp b/test/unit/main.cpp
new file mode 100644
index 0000000..e978630
--- /dev/null
+++ b/test/unit/main.cpp
@@ -0,0 +1,24 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * This program is free software: you can redistribute it and/or modify
+// * it under the terms of the GNU General Public License as published by
+// * the Free Software Foundation, either version 3 of the License, or
+// * (at your option) any later version.
+// *
+// * This program is distributed in the hope that it will be useful,
+// * but WITHOUT ANY WARRANTY; without even the implied warranty of
+// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// * GNU General Public License for more details.
+// *
+// * You should have received a copy of the GNU General Public License
+// * along with this program. If not, see http://www.gnu.org/licenses/.
+
+#include "gtest/gtest.h"
+
+int main(int argc, char* argv[])
+{
+ ::testing::InitGoogleTest(&argc, argv);
+
+ return RUN_ALL_TESTS();
+}
diff --git a/test/unit/math/gendata.m b/test/unit/math/gendata.m
new file mode 100644
index 0000000..5c13491
--- /dev/null
+++ b/test/unit/math/gendata.m
@@ -0,0 +1,86 @@
+% Script in Octave for generating test data
+
+1;
+
+% Returns the minor matrix
+function m = minor(A, r, c)
+
+ m = A;
+ m(r,:) = [];
+ m(:,c) = [];
+
+end;
+
+% Returns the cofactor matrix
+function m = cofactors(A)
+
+ m = zeros(rows(A), columns(A));
+
+ for r = [1 : rows(A)]
+ for c = [1 : columns(A)]
+ m(r, c) = det(minor(A, r, c));
+ if (mod(r + c, 2) == 1)
+ m(r, c) = -m(r, c);
+ end;
+ end;
+ end;
+
+end;
+
+% Prints the matrix as C++ code
+function printout(A, name)
+
+ printf('const float %s[16] = \n', name);
+ printf('{\n');
+
+ for c = [1 : columns(A)]
+ for r = [1 : rows(A)]
+ printf(' %f', A(r,c));
+ if (! ( (r == 4) && (c == 4) ) )
+ printf(',');
+ end;
+ printf('\n');
+ end;
+ end;
+
+ printf('};\n');
+
+end;
+
+printf('// Cofactors\n');
+A = randn(4,4);
+printout(A, 'COF_MAT');
+printf('\n');
+printout(cofactors(A), 'COF_RESULT');
+printf('\n');
+
+printf('\n');
+
+printf('// Det\n');
+A = randn(4,4);
+printout(A, 'DET_MAT');
+printf('\n');
+printf('const float DET_RESULT = %f;', det(A));
+printf('\n');
+
+printf('\n');
+
+printf('// Invert\n');
+A = randn(4,4);
+printout(A, 'INV_MAT');
+printf('\n');
+printout(inv(A), 'COF_RESULT');
+printf('\n');
+
+printf('\n');
+
+printf('// Multiplication\n');
+A = randn(4,4);
+printout(A, 'MUL_A');
+printf('\n');
+B = randn(4,4);
+printout(B, 'MUL_B');
+printf('\n');
+C = A * B;
+printout(C, 'MUL_RESULT');
+printf('\n');
diff --git a/test/unit/math/geometry_test.cpp b/test/unit/math/geometry_test.cpp
new file mode 100644
index 0000000..f50df4e
--- /dev/null
+++ b/test/unit/math/geometry_test.cpp
@@ -0,0 +1,352 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * This program is free software: you can redistribute it and/or modify
+// * it under the terms of the GNU General Public License as published by
+// * the Free Software Foundation, either version 3 of the License, or
+// * (at your option) any later version.
+// *
+// * This program is distributed in the hope that it will be useful,
+// * but WITHOUT ANY WARRANTY; without even the implied warranty of
+// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// * GNU General Public License for more details.
+// *
+// * You should have received a copy of the GNU General Public License
+// * along with this program. If not, see http://www.gnu.org/licenses/.
+
+// math/test/geometry_test.cpp
+
+/* Unit tests for functions in geometry.h */
+
+#include "math/func.h"
+#include "math/geometry.h"
+
+#include "gtest/gtest.h"
+
+
+const float TEST_TOLERANCE = 1e-5;
+
+
+// Test for rewritten function RotateAngle()
+TEST(GeometryTest, RotateAngleTest)
+{
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(0.0f, 0.0f), 0.0f, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(1.0f, 0.0f), 0.0f, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(1.0f, 1.0f), 0.25f * Math::PI, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(0.0f, 2.0f), 0.5f * Math::PI, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(-0.5f, 0.5f), 0.75f * Math::PI, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(-1.0f, 0.0f), Math::PI, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(-1.0f, -1.0f), 1.25f * Math::PI, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(0.0f, -2.0f), 1.5f * Math::PI, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::IsEqual(Math::RotateAngle(1.0f, -1.0f), 1.75f * Math::PI, TEST_TOLERANCE));
+}
+
+// Tests for other altered, complex or uncertain functions
+
+/*
+
+ TODO: write meaningful tests with proper test values
+
+int TestAngle()
+{
+ const Math::Vector u(-0.0786076246943884, 0.2231249091714256, -1.1601361718477805);
+ const Math::Vector v(-1.231228742001907, -1.720549809950561, -0.690468438834111);
+
+ float mathResult = Math::Angle(u, v);
+ float oldMathResult = Angle(VEC_TO_D3DVEC(u), VEC_TO_D3DVEC(v));
+
+ if (! Math::IsEqual(mathResult, oldMathResult, TEST_TOLERANCE) )
+ return __LINE__;
+
+ return 0;
+}
+
+int TestRotateView()
+{
+ const Math::Vector center(0.617909142705555, 0.896939729454538, -0.615041943652284);
+ const float angleH = 44.5;
+ const float angleV = 12.3;
+ const float dist = 34.76;
+
+ Math::Vector mathResult = Math::RotateView(center, angleH, angleV, dist);
+ Math::Vector oldMathResult = D3DVEC_TO_VEC(RotateView(VEC_TO_D3DVEC(center), angleH, angleV, dist));
+
+ if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLookatPoint()
+{
+ const Math::Vector eye(-2.451183170579471, 0.241270270546559, -0.490677411454893);
+ const float angleH = 48.4;
+ const float angleV = 32.4;
+ const float length = 74.44;
+
+ Math::Vector mathResult = Math::LookatPoint(eye, angleH, angleV, length);
+ Math::Vector oldMathResult = D3DVEC_TO_VEC(LookatPoint(VEC_TO_D3DVEC(eye), angleH, angleV, length));
+
+ if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestProjection()
+{
+ const Math::Vector a(0.852064846846319, -0.794279497087496, -0.655779805476688);
+ const Math::Vector b(-0.245838834102304, -0.841115596038861, 0.470457161487799);
+ const Math::Vector p(2.289326061164255, -0.505511362271196, 0.660204551169491);
+
+ Math::Vector mathResult = Math::Projection(a, b, p);
+ Math::Vector oldMathResult = D3DVEC_TO_VEC(Projection(VEC_TO_D3DVEC(a), VEC_TO_D3DVEC(b), VEC_TO_D3DVEC(p)));
+
+ if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadViewMatrix()
+{
+ const Math::Vector from(2.5646013154868874, -0.6058794133917031, -0.0441195127419744);
+ const Math::Vector at(0.728044925765569, -0.206343977871841, 2.543158236935463);
+ const Math::Vector worldUp(-1.893738133660711, -1.009584441407070, 0.521745988225582);
+
+ Math::Matrix mathResult;
+ Math::LoadViewMatrix(mathResult, from, at, worldUp);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ D3DVECTOR fromD3D = VEC_TO_D3DVEC(from);
+ D3DVECTOR atD3D = VEC_TO_D3DVEC(at);
+ D3DVECTOR worldUpD3D = VEC_TO_D3DVEC(worldUp);
+ D3DUtil_SetViewMatrix(mat, fromD3D, atD3D, worldUpD3D);
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadProjectionMatrix()
+{
+ const float fov = 76.3f;
+ const float aspect = 0.891f;
+ const float nearPlane = 12.3f;
+ const float farPlane = 1238.9f;
+
+ Math::Matrix mathResult;
+ Math::LoadProjectionMatrix(mathResult, fov, aspect, nearPlane, farPlane);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ D3DUtil_SetProjectionMatrix(mat, fov, aspect, nearPlane, farPlane);
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadTranslationMatrix()
+{
+ const Math::Vector translation(-0.3631590720995237, 1.6976327614875211, 0.0148815191502145);
+
+ Math::Matrix mathResult;
+ Math::LoadTranslationMatrix(mathResult, translation);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ D3DUtil_SetTranslateMatrix(mat, translation.x, translation.y, translation.z);
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadScaleMatrix()
+{
+ const Math::Vector scale(0.612236460285503, -0.635566935025364, -0.254321375332065);
+
+ Math::Matrix mathResult;
+ Math::LoadScaleMatrix(mathResult, scale);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ D3DUtil_SetScaleMatrix(mat, scale.x, scale.y, scale.z);
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadRotationXMatrix()
+{
+ const float angle = 0.513790685774275;
+
+ Math::Matrix mathResult;
+ Math::LoadRotationXMatrix(mathResult, angle);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ D3DUtil_SetRotateXMatrix(mat, angle);
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadRotationYMatrix()
+{
+ const float angle = -0.569166650127303;
+
+ Math::Matrix mathResult;
+ Math::LoadRotationYMatrix(mathResult, angle);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ D3DUtil_SetRotateYMatrix(mat, angle);
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadRotationZMatrix()
+{
+ const float angle = 0.380448034347452;
+
+ Math::Matrix mathResult;
+ Math::LoadRotationZMatrix(mathResult, angle);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ D3DUtil_SetRotateZMatrix(mat, angle);
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadRotationMatrix()
+{
+ const float angle = -0.987747190637790;
+ const Math::Vector dir(-0.113024727688331, -0.781265998072571, 1.838972397076884);
+
+ Math::Matrix mathResult;
+ Math::LoadRotationMatrix(mathResult, dir, angle);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ D3DVECTOR dirD3D = VEC_TO_D3DVEC(dir);
+ D3DUtil_SetRotationMatrix(mat, dirD3D, angle);
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadRotationXZYMatrix()
+{
+ const Math::Vector angles(-0.841366567984597, -0.100543315396357, 1.610647811559988);
+
+ Math::Matrix mathResult;
+ Math::LoadRotationXZYMatrix(mathResult, angles);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ MatRotateXZY(mat, VEC_TO_D3DVEC(angles));
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestLoadRotationZXYMatrix()
+{
+ const Math::Vector angles(0.275558495480206, -0.224328265970090, 0.943077216574253);
+
+ Math::Matrix mathResult;
+ Math::LoadRotationZXYMatrix(mathResult, angles);
+
+ Math::Matrix oldMathResult;
+ {
+ D3DMATRIX mat;
+ MatRotateZXY(mat, VEC_TO_D3DVEC(angles));
+ oldMathResult = D3DMAT_TO_MAT(mat);
+ }
+
+ if (! Math::MatricesEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+int TestTransform()
+{
+ Math::Matrix transformMatrix(
+ (float[4][4])
+ {
+ { -0.9282074720977896, 0.6794734970319730, -1.3234304946882685, 0.0925294727863890 },
+ { -0.0395527963683484, 0.2897634352353881, 1.9144398570315440, -1.4062267508968478 },
+ { 0.9133323625282361, -0.6741836434774530, -0.2188812951424338, -1.0089184339952666 },
+ { 0.0f, 0.0f, 0.0f, 1.0f }
+ }
+ );
+ Math::Vector vector(-0.314596433318370, -0.622681232583150, -0.371307535743574);
+
+ Math::Vector mathResult = Math::Transform(transformMatrix, vector);
+ Math::Vector oldMathResult = Transform(transformMatrix, vector);
+
+ if (! Math::VectorsEqual(mathResult, oldMathResult, TEST_TOLERANCE))
+ return __LINE__;
+
+ return 0;
+}
+
+*/
+
diff --git a/test/unit/math/matrix_test.cpp b/test/unit/math/matrix_test.cpp
new file mode 100644
index 0000000..6ae2c6b
--- /dev/null
+++ b/test/unit/math/matrix_test.cpp
@@ -0,0 +1,314 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * This program is free software: you can redistribute it and/or modify
+// * it under the terms of the GNU General Public License as published by
+// * the Free Software Foundation, either version 3 of the License, or
+// * (at your option) any later version.
+// *
+// * This program is distributed in the hope that it will be useful,
+// * but WITHOUT ANY WARRANTY; without even the implied warranty of
+// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// * GNU General Public License for more details.
+// *
+// * You should have received a copy of the GNU General Public License
+// * along with this program. If not, see http://www.gnu.org/licenses/.
+
+// math/test/matrix_test.cpp
+
+/*
+ Unit tests for Matrix struct
+
+ Test data was randomly generated and the expected results
+ calculated using GNU Octave.
+ */
+
+#include "math/func.h"
+#include "math/matrix.h"
+
+#include "gtest/gtest.h"
+
+
+const float TEST_TOLERANCE = 1e-6;
+
+
+TEST(MatrixTest, TransposeTest)
+{
+ const Math::Matrix mat(
+ (float[4][4])
+ {
+ { -0.07011674491203920, 1.26145596067429810, 2.09476603598066902, 0.35560176915570696 },
+ { -1.34075615966224704, 1.17988499016709314, 0.00601713429241016, -0.75213676977972566 },
+ { 0.59186722295223981, 0.88089224074765293, 0.70994467464257294, 0.36730385425340212 },
+ { -0.95649396555068111, 0.75912182022565566, 1.34883305778387186, -1.34957997578168754 }
+ }
+ );
+
+ const Math::Matrix expectedTranspose(
+ (float[4][4])
+ {
+ { -0.07011674491203920, -1.34075615966224704, 0.59186722295223981, -0.95649396555068111 },
+ { 1.26145596067429810, 1.17988499016709314, 0.88089224074765293, 0.75912182022565566 },
+ { 2.09476603598066902, 0.00601713429241016, 0.70994467464257294, 1.34883305778387186 },
+ { 0.35560176915570696, -0.75213676977972566, 0.36730385425340212, -1.34957997578168754 }
+ }
+ );
+
+ Math::Matrix transpose = Math::Transpose(mat);
+
+ EXPECT_TRUE(Math::MatricesEqual(transpose, expectedTranspose, TEST_TOLERANCE));
+}
+
+TEST(MatrixTest, CofactorTest)
+{
+ const Math::Matrix mat1(
+ (float[4][4])
+ {
+ { 0.610630320796245, 1.059932357918312, -1.581674311378210, 1.782214448453331 },
+ { 0.191028848211526, -0.813898708757524, 1.516114203870644, 0.395202639476002 },
+ { 0.335142750345279, -0.346586619596529, 0.545382042472336, -0.879268918923072 },
+ { 1.417588151657198, 1.450841789070141, 0.219080104196171, 0.378724047481655 }
+ }
+ );
+
+ const Math::Matrix expectedCofactors1(
+ (float[4][4])
+ {
+ { -2.402679369186782, 2.282452509293019, 1.722732204057644, -0.746939701104385 },
+ { -0.687677756877654, 1.168949180331164, -0.985354966837796, -1.334071111592705 },
+ { -5.115621958424845, 4.229724770159009, 2.529000630782808, 1.481632618355891 },
+ { 0.147480897398694, -2.140677680337111, -1.207189492265546, 0.151236920408051 }
+ }
+ );
+
+ for (int r = 0; r < 4; ++r)
+ {
+ for (int c = 0; c < 4; ++c)
+ {
+ float ret = mat1.Cofactor(r, c);
+ float exp = expectedCofactors1.m[4*c+r];
+ EXPECT_TRUE(Math::IsEqual(ret, exp, TEST_TOLERANCE));
+ }
+ }
+
+ const Math::Matrix mat2(
+ (float[4][4])
+ {
+ { 0.9845099464982393, -0.9091233416532389, -0.6272243714245945, 0.4645001858944354 },
+ { -0.1333308471483736, 0.9128181433725897, -1.0937461393836190, 0.3180936795928376 },
+ { -0.0654324396846289, 0.1014641705415945, 1.5107709042683430, -0.0240560430414690 },
+ { 0.0179638644093347, -1.0695585982782767, -0.1741250853101032, 1.0803106709464336 }
+ }
+ );
+
+ const Math::Matrix expectedCofactors2(
+ (float[4][4])
+ {
+ { 2.0861102207614466, 0.2989010779528912, 0.0746276150537432, 0.2732659822656097 },
+ { 0.6850002886584565, 1.5513169659641379, -0.0503743176545917, 1.5163672441575642 },
+ { 1.2385556680997216, 1.1827709562505695, 1.2282813085138962, 1.3483789679871401 },
+ { -1.0710790241539783, -0.5589604503588883, 0.0100959837872308, 1.1897872684455839 }
+ }
+ );
+
+
+ for (int r = 0; r < 4; ++r)
+ {
+ for (int c = 0; c < 4; ++c)
+ {
+ float ret = mat2.Cofactor(r, c);
+ float exp = expectedCofactors2.m[4*c+r];
+ EXPECT_TRUE(Math::IsEqual(ret, exp, TEST_TOLERANCE));
+ }
+ }
+}
+
+TEST(MatrixTest, DetTest)
+{
+ const Math::Matrix mat1(
+ (float[4][4])
+ {
+ { -0.95880162984708284, 0.24004047608997131, -0.78172309932665407, -0.11604124457222834 },
+ { -0.36230592086261376, -0.75778166876017261, 0.33041059404631740, -1.06001391941094836 },
+ { 0.00260215210936187, 1.27485610196385113, -0.26149859846418033, -0.59669701186364876 },
+ { 0.36899429848485432, 3.01720896813933104, 2.10311476609438719, -1.68627076626448269 }
+ }
+ );
+
+ const float expectedDet1 = 4.07415413729671;
+
+ float ret1 = mat1.Det();
+ EXPECT_TRUE(Math::IsEqual(ret1, expectedDet1, TEST_TOLERANCE));
+
+ const Math::Matrix mat2(
+ (float[4][4])
+ {
+ { -1.0860073221346871, 0.9150354098189495, -0.2723201933559999, 0.2922832160271507 },
+ { -1.0248331304801788, -2.5081237461125205, -1.0277123574586633, -0.2254690663329798 },
+ { -1.4227635282899367, -0.0403846809122684, 0.9216148477171653, 1.2517067488015878 },
+ { -0.1160254467152022, 0.8270675274393656, 1.0327218739781614, -0.3674886870220400 }
+ }
+ );
+
+ const float expectedDet2 = -6.35122307880942;
+
+ float ret2 = mat2.Det();
+ EXPECT_TRUE(Math::IsEqual(ret2, expectedDet2, TEST_TOLERANCE));
+}
+
+TEST(MatrixTest, InverseTest)
+{
+ const Math::Matrix mat1(
+ (float[4][4])
+ {
+ { -2.2829352811514658, -0.9103222363187888, 0.2792976509411680, -0.7984393573193174 },
+ { 2.4823665798689589, -0.0599056759070980, 0.3832364352926366, -1.6404257204372739 },
+ { -0.3841952272526398, -0.8377700696457873, -0.3416328338427138, 1.1746577275723329 },
+ { 0.1746031241954947, -0.4952532117949962, 0.2155084379835037, -1.6586460437329220 }
+ }
+ );
+
+ const Math::Matrix expectedInverse1(
+ (float[4][4])
+ {
+ { -0.119472603171041, 0.331675963276297, 0.187516809009720, -0.137720814290806 },
+ { -0.387591686166085, -0.487284946727583, -0.798527541290274, 0.102991635972060 },
+ { 2.601905603425902, 2.606899016264679, -0.528006148839176, -4.204703326522837 },
+ { 0.441220327151392, 0.519128136207318, 0.189567009205522, -1.194469716136194 }
+ }
+ );
+
+ Math::Matrix inverse1 = mat1.Inverse();
+
+ EXPECT_TRUE(Math::MatricesEqual(inverse1, expectedInverse1, TEST_TOLERANCE));
+
+ const Math::Matrix mat2(
+ (float[4][4])
+ {
+ { -0.05464332404298505, -0.64357755258235749, -0.13017671677619302, -0.56742332785888006 },
+ { 0.29048383600458222, -0.91517047043724875, 0.84517524415561684, 0.51628195547960565 },
+ { 0.00946488004480186, -0.89077382212689293, 0.73565573766341397, -0.15932513521840930 },
+ { -1.01244718912499132, -0.27840911963972276, -0.39189681211309862, 1.18315064340192055 }
+ }
+ );
+
+ const Math::Matrix expectedInverse2(
+ (float[4][4])
+ {
+ { 0.771302711132012, 1.587542278361995, -2.003075114445104, -0.592574156227379 },
+ { -1.208929259769431, -0.786598967848473, 0.607335305808052, -0.154759693303324 },
+ { -1.500037668208218, -0.774300278997914, 1.917800427261255, -0.123268572651291 },
+ { -0.121314770937944, 0.916925149209746, -0.935924950785014, 0.260875394250671 }
+ }
+ );
+
+ Math::Matrix inverse2 = mat2.Inverse();
+
+ EXPECT_TRUE(Math::MatricesEqual(inverse2, expectedInverse2, TEST_TOLERANCE));
+}
+
+TEST(MatrixTest, MultiplyTest)
+{
+ const Math::Matrix mat1A(
+ (float[4][4])
+ {
+ { 0.6561727049162027, -1.4180263627131411, -0.8271026046117423, 2.3919331748512578 },
+ { -0.6035665535146352, 0.0150827348790615, -0.7090794192822540, 0.9057604704594814 },
+ { -0.9871045001223655, -0.4980646811455065, 0.3806177002298990, 0.1520583649240934 },
+ { -0.2721911170792712, 0.7627928194552067, -0.1504091336784158, 0.9747545351840121 }
+ }
+ );
+
+ const Math::Matrix mat1B(
+ (float[4][4])
+ {
+ { -0.2643735892448818, -0.7542994492819621, 0.6082322350568750, 0.0581733424861419 },
+ { 1.0293246070431237, 0.1979285388251341, -0.2932031385332818, 0.8838407179018929 },
+ { 0.3448687251553114, 0.5031654871245456, 0.7554693012922442, -0.4845315903845708 },
+ { -1.8662838497278593, -0.7843850624747805, 0.1389026096476257, -1.3686415408300689 }
+ }
+ );
+
+ const Math::Matrix expectedMultiply1(
+ (float[4][4])
+ {
+ { -6.382352236417988, -3.067984733682130, 0.522270304251466, -4.088079444498280 },
+ { -1.759853366848825, -0.608994052024491, -0.781406179437379, -0.917870775786188 },
+ { -0.404226802169062, 0.718232546720114, -0.145688356880835, -0.890167707987175 },
+ { -1.013918490922430, -0.483971504099758, -0.367442194643757, -0.602858486133615 }
+ }
+ );
+
+ Math::Matrix multiply1 = Math::MultiplyMatrices(mat1A, mat1B);
+ EXPECT_TRUE(Math::MatricesEqual(multiply1, expectedMultiply1, TEST_TOLERANCE));
+
+ const Math::Matrix mat2A(
+ (float[4][4])
+ {
+ { 0.8697203025776754, 2.1259475710644935, 1.7856691009707812, -2.1563963348328126 },
+ { 1.5888074489288735, -0.0794849733953615, 0.7307782768677457, 0.7943129159612630 },
+ { 0.2859761537233830, -0.6231231890384962, -0.0496743172880377, -0.8137857518646087 },
+ { 1.2670547229512983, -0.5305171374831831, -0.4987412674062375, -1.1257327113869595 }
+ }
+ );
+
+ const Math::Matrix mat2B(
+ (float[4][4])
+ {
+ { 1.1321105701165317, 0.1759563504574463, -2.0675778912000418, 1.4840339814245538 },
+ { -1.5117280888829916, -0.0933013188828093, -0.2079262944351640, 0.9575727579539316 },
+ { 0.3615378398970173, 1.2465163589027248, 1.1326150997082589, 0.9921208694352303 },
+ { -0.7357104529373861, -0.4774022005969588, -0.2118739096676499, 1.1427567093270703 }
+ }
+ );
+
+ const Math::Matrix expectedMultiply2(
+ (float[4][4])
+ {
+ { 0.00283516267056338, 3.21001319965989307, 0.23910503934370686, 2.63380716363006107 },
+ { 1.59868505822469742, 0.81869715594617765, -2.60905981088293570, 3.91445839239110294 },
+ { 1.84650099286297942, 0.43504079532852930, -0.34555619012424243, -1.15152951542451487 },
+ { 2.88434318563174585, 0.18818239851585700, -2.83579436909308980, -0.40890672198610400 }
+ }
+ );
+
+ Math::Matrix multiply2 = Math::MultiplyMatrices(mat2A, mat2B);
+ EXPECT_TRUE(Math::MatricesEqual(multiply2, expectedMultiply2, TEST_TOLERANCE));
+}
+
+TEST(MatrixTest, MultiplyVectorTest)
+{
+ const Math::Matrix mat1(
+ (float[4][4])
+ {
+ { 0.188562846910008, -0.015148651460679, 0.394512304108827, 0.906910631257135 },
+ { -0.297506779519667, 0.940119328178913, 0.970957796752517, 0.310559318965526 },
+ { -0.819770525290873, -2.316574438778879, 0.155756069319732, -0.855661405742964 },
+ { 0.000000000000000, 0.000000000000000, 0.000000000000000, 1.000000000000000 }
+ }
+ );
+
+ const Math::Vector vec1(-0.824708565156661, -1.598287748103842, -0.422498044734181);
+
+ const Math::Vector expectedMultiply1(0.608932463260470, -1.356893266403749, 3.457156276255142);
+
+ Math::Vector multiply1 = Math::MatrixVectorMultiply(mat1, vec1, false);
+ EXPECT_TRUE(Math::VectorsEqual(multiply1, expectedMultiply1, TEST_TOLERANCE));
+
+ const Math::Matrix mat2(
+ (float[4][4])
+ {
+ { -0.63287117038834284, 0.55148060401816856, -0.02042395559467368, -1.50367083897656850 },
+ { 0.69629042156335297, 0.12982747869796774, -1.16250029235919405, 1.19084447253756909 },
+ { 0.44164132914357224, -0.15169304045662041, -0.00880583574621390, -0.55817802940035310 },
+ { 0.95680476533530789, -1.51912346889253125, -0.74209769406615944, -0.20938988867903682 }
+ }
+ );
+
+ const Math::Vector vec2(0.330987381051962, 1.494375516393466, 1.483422335561857);
+
+ const Math::Vector expectedMultiply2(0.2816820577317669, 0.0334468811767428, 0.1996974284970455);
+
+ Math::Vector multiply2 = Math::MatrixVectorMultiply(mat2, vec2, true);
+ EXPECT_TRUE(Math::VectorsEqual(multiply2, expectedMultiply2, TEST_TOLERANCE));
+}
diff --git a/test/unit/math/vector_test.cpp b/test/unit/math/vector_test.cpp
new file mode 100644
index 0000000..199f4c3
--- /dev/null
+++ b/test/unit/math/vector_test.cpp
@@ -0,0 +1,74 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * This program is free software: you can redistribute it and/or modify
+// * it under the terms of the GNU General Public License as published by
+// * the Free Software Foundation, either version 3 of the License, or
+// * (at your option) any later version.
+// *
+// * This program is distributed in the hope that it will be useful,
+// * but WITHOUT ANY WARRANTY; without even the implied warranty of
+// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// * GNU General Public License for more details.
+// *
+// * You should have received a copy of the GNU General Public License
+// * along with this program. If not, see http://www.gnu.org/licenses/.
+
+// math/test/vector_test.cpp
+
+/*
+ Unit tests for Vector struct
+
+ Test data was randomly generated and the expected results
+ calculated using GNU Octave.
+ */
+
+#include "math/func.h"
+#include "math/vector.h"
+
+#include "gtest/gtest.h"
+
+
+const float TEST_TOLERANCE = 1e-6;
+
+
+TEST(VectorTest, LengthTest)
+{
+ Math::Vector vec(-1.288447945923275, 0.681452565308134, -0.633761098985957);
+ const float expectedLength = 1.58938001708428;
+
+ EXPECT_TRUE(Math::IsEqual(vec.Length(), expectedLength, TEST_TOLERANCE));
+}
+
+TEST(VectorTest, NormalizeTest)
+{
+ Math::Vector vec(1.848877241804398, -0.157262961268577, -1.963031403332377);
+ const Math::Vector expectedNormalized(0.6844609421393856, -0.0582193085618106, -0.7267212194481797);
+
+ vec.Normalize();
+
+ EXPECT_TRUE(Math::VectorsEqual(vec, expectedNormalized, TEST_TOLERANCE));
+}
+
+TEST(VectorTest, DotTest)
+{
+ Math::Vector vecA(0.8202190530968309, 0.0130926060162780, 0.2411914183883510);
+ Math::Vector vecB(-0.0524083951404069, 1.5564932716738220, -0.8971342631500536);
+
+ float expectedDot = -0.238988896477326;
+
+ EXPECT_TRUE(Math::IsEqual(Math::DotProduct(vecA, vecB), expectedDot, TEST_TOLERANCE));
+}
+
+TEST(VectorTest, CrossTest)
+{
+ Math::Vector vecA(1.37380499798567, 1.18054518384682, 1.95166361293121);
+ Math::Vector vecB(0.891657855926886, 0.447591335394532, -0.901604070087823);
+
+ Math::Vector expectedCross(-1.937932065431669, 2.978844370287636, -0.437739173833581);
+ Math::Vector expectedReverseCross = -expectedCross;
+
+ EXPECT_TRUE(Math::VectorsEqual(vecA.CrossMultiply(vecB), expectedCross, TEST_TOLERANCE));
+
+ EXPECT_TRUE(Math::VectorsEqual(vecB.CrossMultiply(vecA), expectedReverseCross, TEST_TOLERANCE));
+}
diff --git a/test/unit/ui/CMakeLists.txt b/test/unit/ui/CMakeLists.txt
new file mode 100644
index 0000000..32af230
--- /dev/null
+++ b/test/unit/ui/CMakeLists.txt
@@ -0,0 +1,29 @@
+set(SRC_DIR ${colobot_SOURCE_DIR}/src)
+
+include_directories(
+.
+${SRC_DIR}
+${GTEST_INCLUDE_DIR}
+${GMOCK_INCLUDE_DIR}
+)
+
+add_executable(edit_test
+${SRC_DIR}/common/event.cpp
+${SRC_DIR}/common/logger.cpp
+${SRC_DIR}/common/misc.cpp
+${SRC_DIR}/common/iman.cpp
+${SRC_DIR}/common/stringutils.cpp
+${SRC_DIR}/graphics/engine/text.cpp
+${SRC_DIR}/ui/button.cpp
+${SRC_DIR}/ui/control.cpp
+${SRC_DIR}/ui/edit.cpp
+${SRC_DIR}/ui/scroll.cpp
+stubs/app_stub.cpp
+stubs/engine_stub.cpp
+stubs/particle_stub.cpp
+stubs/restext_stub.cpp
+stubs/robotmain_stub.cpp
+edit_test.cpp)
+target_link_libraries(edit_test gtest gmock ${SDL_LIBRARY} ${SDLTTF_LIBRARY} ${Boost_LIBRARIES})
+
+add_test(edit_test ./edit_test)
diff --git a/test/unit/ui/edit_test.cpp b/test/unit/ui/edit_test.cpp
new file mode 100644
index 0000000..f878f4b
--- /dev/null
+++ b/test/unit/ui/edit_test.cpp
@@ -0,0 +1,74 @@
+#include "app/app.h"
+#include "ui/edit.h"
+#include "mocks/text_mock.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <fstream>
+
+class CEditTest : public testing::Test
+{
+public:
+ CEditTest(){};
+
+ virtual void SetUp()
+ {
+ m_engine = new Gfx::CEngine(&m_iMan, NULL);
+
+ m_iMan.AddInstance(CLASS_ENGINE, m_engine);
+ m_edit = new Ui::CEdit;
+ }
+
+ virtual void TearDown()
+ {
+ m_iMan.DeleteInstance(CLASS_ENGINE, m_engine);
+ delete m_engine;
+ m_engine = NULL;
+ delete m_edit;
+ m_edit = NULL;
+
+ }
+ virtual ~CEditTest()
+ {
+
+ };
+
+protected:
+ CInstanceManager m_iMan;
+ CApplication m_app;
+ Gfx::CEngine * m_engine;
+ Ui::CEdit * m_edit;
+ CLogger m_logger;
+};
+
+using ::testing::_;
+using ::testing::Return;
+
+TEST_F(CEditTest, WriteTest)
+{
+ ASSERT_TRUE(true);
+ CTextMock * text = dynamic_cast<CTextMock *>(m_engine->GetText());
+ EXPECT_CALL(*text, GetCharWidth(_, _, _, _)).WillRepeatedly(Return(1.0f));
+ EXPECT_CALL(*text, GetStringWidth(_, _, _)).WillOnce(Return(1.0f));
+ std::string filename = "test.file";
+ m_edit->SetMaxChar(Ui::EDITSTUDIOMAX);
+ m_edit->SetAutoIndent(true);
+ std::string inputScript = "{\ntext1\ntext2\n\ntext3\n{\ntext4\n}\n}";
+ std::string expectedScript = "{\r\n\ttext1\r\n\ttext2\r\n\t\r\n\ttext3\r\n\t{\r\n\t\ttext4\r\n\t}\r\n}";
+ m_edit->SetText(inputScript.c_str(), true);
+ GetLogger()->Info("Writing text \n");
+ m_edit->WriteText("script.txt");
+
+ std::fstream scriptFile;
+
+ scriptFile.open("script.txt", std::ios_base::binary | std::ios_base::in);
+ std::string outputScript((std::istreambuf_iterator<char>(scriptFile)), std::istreambuf_iterator<char>());
+ ASSERT_STREQ(expectedScript.c_str(), outputScript.c_str());
+}
+
+int main(int argc, char *argv[])
+{
+ ::testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
+
diff --git a/test/unit/ui/mocks/text_mock.h b/test/unit/ui/mocks/text_mock.h
new file mode 100644
index 0000000..f0ad339
--- /dev/null
+++ b/test/unit/ui/mocks/text_mock.h
@@ -0,0 +1,21 @@
+#include "common/logger.h"
+#include "graphics/engine/text.h"
+
+#include <gmock/gmock.h>
+
+class CTextMock : public Gfx::CText
+{
+public:
+ CTextMock(CInstanceManager *iMan, Gfx::CEngine* engine) : CText(iMan, engine)
+ {
+ }
+
+ virtual ~CTextMock()
+ {
+ };
+
+ MOCK_METHOD4(GetCharWidth, float(Gfx::UTF8Char, Gfx::FontType, float, float));
+ MOCK_METHOD3(GetStringWidth, float(const std::string &, Gfx::FontType, float));
+
+};
+
diff --git a/test/unit/ui/stubs/app_stub.cpp b/test/unit/ui/stubs/app_stub.cpp
new file mode 100644
index 0000000..70d9e82
--- /dev/null
+++ b/test/unit/ui/stubs/app_stub.cpp
@@ -0,0 +1,26 @@
+#include "app/app.h"
+#include "graphics/opengl/gldevice.h"
+
+template<> CApplication* CSingleton<CApplication>::mInstance = nullptr;
+
+namespace Gfx {
+
+GLDeviceConfig::GLDeviceConfig()
+{
+}
+
+} /* Gfx */
+CApplication::CApplication()
+{
+}
+
+CApplication::~CApplication()
+{
+}
+
+std::string CApplication::GetDataFilePath(DataDir /* dataDir */, const std::string& subpath)
+{
+ return subpath;
+}
+
+
diff --git a/test/unit/ui/stubs/engine_stub.cpp b/test/unit/ui/stubs/engine_stub.cpp
new file mode 100644
index 0000000..de7bbe7
--- /dev/null
+++ b/test/unit/ui/stubs/engine_stub.cpp
@@ -0,0 +1,79 @@
+#include "graphics/engine/engine.h"
+#include "graphics/engine/text.h"
+#include "mocks/text_mock.h"
+
+namespace Gfx {
+
+CEngine::CEngine(CInstanceManager* iMan, CApplication* app) :
+ m_iMan(iMan), m_app(app)
+{
+ m_text = new CTextMock(m_iMan, this);
+ m_text->Create();
+}
+
+CEngine::~CEngine()
+{
+ delete m_text;
+ m_text = NULL;
+}
+
+Math::Point CEngine::WindowToInterfaceSize(Math::IntPoint size)
+{
+ return Math::Point(size.x, size.y);
+}
+
+void CEngine::SetState(int state, const Color& color)
+{
+ if (state == m_lastState && color == m_lastColor)
+ return;
+
+ m_lastState = state;
+ m_lastColor = color;
+}
+
+Math::IntPoint CEngine::GetWindowSize()
+{
+ return m_size;
+}
+
+void CEngine::AddStatisticTriangle(int count)
+{
+ m_statisticTriangle += count;
+}
+
+void CEngine::SetMouseType(EngineMouseType type)
+{
+ m_mouseType = type;
+}
+
+bool CEngine::SetTexture(const std::string& /* name */, int /* stage */)
+{
+ return true;
+}
+
+CText* CEngine::GetText()
+{
+ return m_text;
+}
+
+CDevice* CEngine::GetDevice()
+{
+ return m_device;
+}
+
+int CEngine::GetEditIndentValue()
+{
+ return m_editIndentValue;
+}
+
+void CEngine::DeleteTexture(const std::string& /* texName */)
+{
+}
+Texture CEngine::LoadTexture(const std::string& /* name */)
+{
+ Texture texture;
+ return texture;
+}
+
+} /* Gfx */
+
diff --git a/test/unit/ui/stubs/particle_stub.cpp b/test/unit/ui/stubs/particle_stub.cpp
new file mode 100644
index 0000000..c3bf6dc
--- /dev/null
+++ b/test/unit/ui/stubs/particle_stub.cpp
@@ -0,0 +1,205 @@
+#include "graphics/engine/particle.h"
+
+#include "common/logger.h"
+
+
+// Graphics module namespace
+namespace Gfx {
+
+
+CParticle::CParticle(CInstanceManager* /*iMan*/, CEngine* /*engine*/)
+{
+}
+
+CParticle::~CParticle()
+{
+}
+
+void CParticle::SetDevice(CDevice* /*device*/)
+{
+}
+
+void CParticle::FlushParticle()
+{
+}
+
+void CParticle::FlushParticle(int /*sheet*/)
+{
+}
+
+int CParticle::CreateParticle(Math::Vector /*pos*/, Math::Vector /*speed*/, Math::Point /*dim*/,
+ ParticleType /*type*/, float /*duration*/, float /*mass*/,
+ float /*windSensitivity*/, int /*sheet*/)
+{
+ return 0;
+}
+
+int CParticle::CreateFrag(Math::Vector /*pos*/, Math::Vector /*speed*/, EngineTriangle */*triangle*/,
+ ParticleType /*type*/, float /*duration*/, float /*mass*/,
+ float /*windSensitivity*/, int /*sheet*/)
+{
+ return 0;
+}
+
+int CParticle::CreatePart(Math::Vector /*pos*/, Math::Vector /*speed*/, ParticleType /*type*/,
+ float /*duration*/, float /*mass*/, float /*weight*/,
+ float /*windSensitivity*/, int /*sheet*/)
+{
+ return 0;
+}
+
+int CParticle::CreateRay(Math::Vector /*pos*/, Math::Vector /*goal*/, ParticleType /*type*/, Math::Point /*dim*/,
+ float /*duration*/, int /*sheet*/)
+{
+ return 0;
+}
+
+int CParticle::CreateTrack(Math::Vector /*pos*/, Math::Vector /*speed*/, Math::Point /*dim*/, ParticleType /*type*/,
+ float /*duration*/, float /*mass*/, float /*length*/, float /*width*/)
+{
+ return 0;
+}
+
+void CParticle::CreateWheelTrace(const Math::Vector &/*p1*/, const Math::Vector &/*p2*/, const Math::Vector &/*p3*/,
+ const Math::Vector &/*p4*/, ParticleType /*type*/)
+{
+}
+
+void CParticle::DeleteParticle(ParticleType /*type*/)
+{
+}
+
+void CParticle::DeleteParticle(int /*channel*/)
+{
+}
+
+void CParticle::SetObjectLink(int /*channel*/, CObject */*object*/)
+{
+}
+
+void CParticle::SetObjectFather(int /*channel*/, CObject */*object*/)
+{
+}
+
+void CParticle::SetPosition(int /*channel*/, Math::Vector /*pos*/)
+{
+}
+
+void CParticle::SetDimension(int /*channel*/, Math::Point /*dim*/)
+{
+}
+
+void CParticle::SetZoom(int /*channel*/, float /*zoom*/)
+{
+}
+
+void CParticle::SetAngle(int /*channel*/, float /*angle*/)
+{
+}
+
+void CParticle::SetIntensity(int /*channel*/, float /*intensity*/)
+{
+}
+
+void CParticle::SetParam(int /*channel*/, Math::Vector /*pos*/, Math::Point /*dim*/, float /*zoom*/, float /*angle*/, float /*intensity*/)
+{
+}
+
+void CParticle::SetPhase(int /*channel*/, ParticlePhase /*phase*/, float /*duration*/)
+{
+}
+
+bool CParticle::GetPosition(int /*channel*/, Math::Vector &/*pos*/)
+{
+ return true;
+}
+
+Color CParticle::GetFogColor(Math::Vector /*pos*/)
+{
+ return Color();
+}
+
+void CParticle::SetFrameUpdate(int /*sheet*/, bool /*update*/)
+{
+}
+
+void CParticle::FrameParticle(float /*rTime*/)
+{
+}
+
+void CParticle::DrawParticle(int /*sheet*/)
+{
+}
+
+bool CParticle::WriteWheelTrace(const char */*filename*/, int /*width*/, int /*height*/, Math::Vector /*dl*/, Math::Vector /*ur*/)
+{
+ return true;
+}
+
+void CParticle::DeleteRank(int /*rank*/)
+{
+}
+
+bool CParticle::CheckChannel(int &/*channel*/)
+{
+ return true;
+}
+
+void CParticle::DrawParticleTriangle(int /*i*/)
+{
+}
+
+void CParticle::DrawParticleNorm(int /*i*/)
+{
+}
+
+void CParticle::DrawParticleFlat(int /*i*/)
+{
+}
+
+void CParticle::DrawParticleFog(int /*i*/)
+{
+}
+
+void CParticle::DrawParticleRay(int /*i*/)
+{
+}
+
+void CParticle::DrawParticleSphere(int /*i*/)
+{
+}
+
+void CParticle::DrawParticleCylinder(int /*i*/)
+{
+}
+
+void CParticle::DrawParticleWheel(int /*i*/)
+{
+}
+
+CObject* CParticle::SearchObjectGun(Math::Vector /*old*/, Math::Vector /*pos*/, ParticleType /*type*/, CObject */*father*/)
+{
+ return nullptr;
+}
+
+CObject* CParticle::SearchObjectRay(Math::Vector /*pos*/, Math::Vector /*goal*/, ParticleType /*type*/, CObject */*father*/)
+{
+ return nullptr;
+}
+
+void CParticle::Play(Sound /*sound*/, Math::Vector /*pos*/, float /*amplitude*/)
+{
+}
+
+bool CParticle::TrackMove(int /*i*/, Math::Vector /*pos*/, float /*progress*/)
+{
+ return true;
+}
+
+void CParticle::TrackDraw(int /*i*/, ParticleType /*type*/)
+{
+}
+
+
+} // namespace Gfx
+
diff --git a/test/unit/ui/stubs/restext_stub.cpp b/test/unit/ui/stubs/restext_stub.cpp
new file mode 100644
index 0000000..004da19
--- /dev/null
+++ b/test/unit/ui/stubs/restext_stub.cpp
@@ -0,0 +1,12 @@
+#include "common/restext.h"
+
+bool GetResource(ResType /* type */, int /* num */, char* /* text */)
+{
+ return true;
+}
+
+bool SearchKey(const char * /* cmd */, InputSlot & /* key */)
+{
+ return true;
+}
+
diff --git a/test/unit/ui/stubs/robotmain_stub.cpp b/test/unit/ui/stubs/robotmain_stub.cpp
new file mode 100644
index 0000000..a36b1a1
--- /dev/null
+++ b/test/unit/ui/stubs/robotmain_stub.cpp
@@ -0,0 +1,17 @@
+#include "object/robotmain.h"
+
+
+template<> CRobotMain* CSingleton<CRobotMain>::mInstance = nullptr;
+
+bool CRobotMain::GetGlint()
+{
+ return false;
+}
+
+const InputBinding& CRobotMain::GetInputBinding(InputSlot slot)
+{
+ unsigned int index = static_cast<unsigned int>(slot);
+ assert(index >= 0 && index < INPUT_SLOT_MAX);
+ return m_inputBindings[index];
+}
+
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-07-05 19:37:41 +0000