All changes done in main branch

src/Blazor3D/Blazor3D.Tests/Blazor3D.Tests.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>net6.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+
+		<IsPackable>false</IsPackable>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
+		<PackageReference Include="MSTest.TestAdapter" Version="2.2.10" />
+		<PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
+		<PackageReference Include="coverlet.collector" Version="3.1.2" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\Blazor3D\Blazor3D.csproj" />
+	</ItemGroup>
+
+</Project>

src/Blazor3D/Blazor3D.Tests/Cameras/OrthographicCameraTests.cs

@@ -0,0 +1,36 @@
+namespace Blazor3D.Tests.Cameras;
+
+[TestClass]
+public class OrthographicCameraTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var camera = new OrthographicCamera();
+        Assert.AreEqual("OrthographicCamera", camera.Type);
+        Assert.AreEqual(0.1, camera.Near);
+        Assert.AreEqual(2000, camera.Far);
+        Assert.AreEqual(-1, camera.Left);
+        Assert.AreEqual(1, camera.Right);
+        Assert.AreEqual(1, camera.Top);
+        Assert.AreEqual(-1, camera.Bottom);
+        Assert.AreEqual(1, camera.Zoom);
+        Assert.IsNotNull(camera.AnimateRotationSettings);
+        Assert.IsNotNull(camera.LookAt);
+        Assert.IsNotNull(camera.Up);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var camera = new OrthographicCamera(left: -2, right: 2, top: 2, bottom: -2, near: 0, far: 100, zoom: 0.5);
+        Assert.AreEqual("OrthographicCamera", camera.Type);
+        Assert.AreEqual(0, camera.Near);
+        Assert.AreEqual(100, camera.Far);
+        Assert.AreEqual(-2, camera.Left);
+        Assert.AreEqual(2, camera.Right);
+        Assert.AreEqual(2, camera.Top);
+        Assert.AreEqual(-2, camera.Bottom);
+        Assert.AreEqual(0.5, camera.Zoom);
+    }
+}

src/Blazor3D/Blazor3D.Tests/Cameras/PerspectiveCameraTests.cs

@@ -0,0 +1,27 @@
+namespace Blazor3D.Tests.Cameras;
+
+[TestClass]
+public class PerspectiveCameraTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var camera = new PerspectiveCamera();
+        Assert.AreEqual("PerspectiveCamera", camera.Type);
+        Assert.AreEqual(0.1, camera.Near);
+        Assert.AreEqual(1000, camera.Far);
+        Assert.AreEqual(75, camera.Fov);
+        Assert.IsNotNull(camera.AnimateRotationSettings);
+        Assert.IsNotNull(camera.LookAt);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithPredefinedValues()
+    {
+        var camera = new PerspectiveCamera(fov: 10, near: 0.2, far: 100);
+        Assert.AreEqual("PerspectiveCamera", camera.Type);
+        Assert.AreEqual(0.2, camera.Near);
+        Assert.AreEqual(100, camera.Far);
+        Assert.AreEqual(10, camera.Fov);
+    }
+}

src/Blazor3D/Blazor3D.Tests/GlobalUsings.cs

@@ -0,0 +1,5 @@
+global using Blazor3D.Cameras;
+global using Blazor3D.Helpers;
+global using Blazor3D.Maths;
+global using Blazor3D.Settings;
+global using Microsoft.VisualStudio.TestTools.UnitTesting;

src/Blazor3D/Blazor3D.Tests/Helpers/ArrowHelperTests.cs

@@ -0,0 +1,45 @@
+namespace Blazor3D.Tests.Helpers;
+
+[TestClass]
+public class ArrowHelperTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var arrow = new ArrowHelper();
+        Assert.AreEqual("ArrowHelper", arrow.Type);
+        Assert.AreEqual(0, arrow.Dir.X);
+        Assert.AreEqual(0, arrow.Dir.Y);
+        Assert.AreEqual(1, arrow.Dir.Z);
+        Assert.AreEqual(0, arrow.Origin.X);
+        Assert.AreEqual(0, arrow.Origin.Y);
+        Assert.AreEqual(0, arrow.Origin.Z);
+        Assert.AreEqual(1, arrow.Length);
+        Assert.AreEqual("0xffff00", arrow.Color);
+        Assert.AreEqual(0.2, arrow.HeadLength);
+        Assert.AreEqual(0.2 * 0.2, arrow.HeadWidth);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var arrow = new ArrowHelper(
+            dir: new Vector3(3, 3, 3),
+            origin: new Vector3(3, 3, 3),
+            length: 5,
+            color: "red",
+            headLength: 2,
+            headWidth: 4);
+        Assert.AreEqual("ArrowHelper", arrow.Type);
+        Assert.AreEqual(3, arrow.Dir.X);
+        Assert.AreEqual(3, arrow.Dir.Y);
+        Assert.AreEqual(3, arrow.Dir.Z);
+        Assert.AreEqual(3, arrow.Origin.X);
+        Assert.AreEqual(3, arrow.Origin.Y);
+        Assert.AreEqual(3, arrow.Origin.Z);
+        Assert.AreEqual(5, arrow.Length);
+        Assert.AreEqual("red", arrow.Color);
+        Assert.AreEqual(2, arrow.HeadLength);
+        Assert.AreEqual(4, arrow.HeadWidth);
+    }
+}

src/Blazor3D/Blazor3D.Tests/Helpers/AxesHelperTests.cs

@@ -0,0 +1,21 @@
+namespace Blazor3D.Tests.Helpers;
+
+[TestClass]
+public class AxesHelperTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var helper = new AxesHelper();
+        Assert.AreEqual("AxesHelper", helper.Type);
+        Assert.AreEqual(1, helper.Size);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var helper = new AxesHelper(5);
+        Assert.AreEqual("AxesHelper", helper.Type);
+        Assert.AreEqual(5, helper.Size);
+    }
+}

src/Blazor3D/Blazor3D.Tests/Helpers/BoxHelperTests.cs

@@ -0,0 +1,26 @@
+using Blazor3D.Objects;
+
+namespace Blazor3D.Tests.Helpers;
+
+[TestClass]
+public class BoxHelperTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var helper = new BoxHelper();
+        Assert.AreEqual("BoxHelper", helper.Type);
+        Assert.IsNull(helper.Object3D);
+        Assert.AreEqual("0xffff00", helper.Color);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var mesh = new Mesh();
+        var helper = new BoxHelper(mesh, "red");
+        Assert.AreEqual("BoxHelper", helper.Type);
+        Assert.IsNotNull(helper.Object3D);
+        Assert.AreEqual("red", helper.Color);
+    }
+}

src/Blazor3D/Blazor3D.Tests/Helpers/GridHelperTests.cs

@@ -0,0 +1,27 @@
+namespace Blazor3D.Tests.Helpers;
+
+[TestClass]
+public class GridHelperTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var grid = new GridHelper();
+        Assert.AreEqual("GridHelper", grid.Type);
+        Assert.AreEqual(10, grid.Size);
+        Assert.AreEqual(10, grid.Divisions);
+        Assert.AreEqual("0x444444", grid.ColorCenterLine);
+        Assert.AreEqual("0x888888", grid.ColorGrid);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var grid = new GridHelper(6, 6, "red", "orange");
+        Assert.AreEqual("GridHelper", grid.Type);
+        Assert.AreEqual(6, grid.Size);
+        Assert.AreEqual(6, grid.Divisions);
+        Assert.AreEqual("red", grid.ColorCenterLine);
+        Assert.AreEqual("orange", grid.ColorGrid);
+    }
+}

src/Blazor3D/Blazor3D.Tests/Helpers/PlaneHelperTests.cs

@@ -0,0 +1,35 @@
+namespace Blazor3D.Tests.Helpers;
+
+[TestClass]
+public class PlaneHelperTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var plane = new PlaneHelper();
+        Assert.AreEqual("PlaneHelper", plane.Type);
+        Assert.IsNotNull(plane.Plane);
+        Assert.IsNotNull(plane.Plane.Normal);
+        Assert.AreEqual(1, plane.Plane.Normal.X);
+        Assert.AreEqual(0, plane.Plane.Normal.Y);
+        Assert.AreEqual(0, plane.Plane.Normal.Z);
+        Assert.AreEqual(0, plane.Plane.Constant);
+        Assert.AreEqual(1, plane.Size);
+        Assert.AreEqual("0xffff00", plane.Color);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var plane = new PlaneHelper(new Plane(new Vector3(1, 1, 1), 1));
+        Assert.AreEqual("PlaneHelper", plane.Type);
+        Assert.IsNotNull(plane.Plane);
+        Assert.IsNotNull(plane.Plane.Normal);
+        Assert.AreEqual(1, plane.Plane.Normal.X);
+        Assert.AreEqual(1, plane.Plane.Normal.Y);
+        Assert.AreEqual(1, plane.Plane.Normal.Z);
+        Assert.AreEqual(1, plane.Plane.Constant);
+        Assert.AreEqual(1, plane.Size);
+        Assert.AreEqual("0xffff00", plane.Color);
+    }
+}

src/Blazor3D/Blazor3D.Tests/Helpers/PointLightHelperTests.cs

@@ -0,0 +1,33 @@
+using Blazor3D.Lights;
+
+namespace Blazor3D.Tests.Helpers;
+
+[TestClass]
+public class PointLightHelperTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var helper = new PointLightHelper();
+        Assert.AreEqual("PointLightHelper", helper.Type);
+        Assert.IsNotNull(helper.Light);
+        Assert.IsNull(helper.Color);
+        Assert.AreEqual(1, helper.SphereSize);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var light = new PointLight
+        {
+            Color = "red"
+        };
+
+        var helper = new PointLightHelper(light, 2, "blue");
+        Assert.AreEqual("PointLightHelper", helper.Type);
+        Assert.IsNotNull(helper.Light);
+        Assert.AreEqual("red", helper.Light.Color);
+        Assert.AreEqual(2, helper.SphereSize);
+        Assert.AreEqual("blue", helper.Color);
+    }
+}

src/Blazor3D/Blazor3D.Tests/Helpers/PolarGridHelperTests.cs

@@ -0,0 +1,31 @@
+namespace Blazor3D.Tests.Helpers;
+
+[TestClass]
+public class PolarGridHelperTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var grid = new PolarGridHelper();
+        Assert.AreEqual("PolarGridHelper", grid.Type);
+        Assert.AreEqual(10, grid.Radius);
+        Assert.AreEqual(16, grid.Radials);
+        Assert.AreEqual(8, grid.Circles);
+        Assert.AreEqual(64, grid.Divisions);
+        Assert.AreEqual("0x444444", grid.Color1);
+        Assert.AreEqual("0x888888", grid.Color2);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var grid = new PolarGridHelper(2, 2, 6, 32, "red", "orange");
+        Assert.AreEqual("PolarGridHelper", grid.Type);
+        Assert.AreEqual(2, grid.Radius);
+        Assert.AreEqual(2, grid.Radials);
+        Assert.AreEqual(6, grid.Circles);
+        Assert.AreEqual(32, grid.Divisions);
+        Assert.AreEqual("red", grid.Color1);
+        Assert.AreEqual("orange", grid.Color2);
+    }
+}

src/Blazor3D/Blazor3D.Tests/Settings/AnimateRotationSettingsTests.cs

@@ -0,0 +1,29 @@
+namespace Blazor3D.Tests.Settings;
+
+[TestClass]
+public class AnimateRotationSettingsTests
+{
+    [TestMethod]
+    public void DefaultConstructorShouldCreateWithPredefinedValues()
+    {
+        var settings = new AnimateRotationSettings();
+
+        Assert.AreEqual(false, settings.AnimateRotation);
+        Assert.AreEqual(0.1, settings.ThetaX);
+        Assert.AreEqual(0.1, settings.ThetaY);
+        Assert.AreEqual(0.1, settings.ThetaZ);
+        Assert.AreEqual(5, settings.Radius);
+    }
+
+    [TestMethod]
+    public void ConstructorWithParamsShouldCreateWithSpecifiedValues()
+    {
+        var settings = new AnimateRotationSettings(true, 1, 1, 1, 1);
+
+        Assert.AreEqual(true, settings.AnimateRotation);
+        Assert.AreEqual(1, settings.ThetaX);
+        Assert.AreEqual(1, settings.ThetaY);
+        Assert.AreEqual(1, settings.ThetaZ);
+        Assert.AreEqual(1, settings.Radius);
+    }
+}