backup/anx.framework
1
0
Fork 0
Code Issues Pull Requests Projects Releases Activity

Vector3: fixed a minor issue with divide by factor

Browse Source 
Color: fixed some issues and implemented some missing methods
TestCenter: refactoring (moved all ConvertEquals-Methods to the new AssertHelper)
DataFactory: extended by normalized random floats
TestCenter: all Color tests are green now
This commit is contained in:
Glatzemann 2011-11-04 06:46:24 +00:00
parent 3e6d9b001e
commit 7423fd4532
13 changed files with 498 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ANX.Framework.TestCenter/ANX.Framework.TestCenter.csproj
View File

@ -49,6 +49,7 @@
<Reference Include="System.Xml" /> <Reference Include="System.Xml" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="AssertHelper.cs" />
<Compile Include="ContentPipeline\Helper\SharedResource.cs" /> <Compile Include="ContentPipeline\Helper\SharedResource.cs" />
<Compile Include="ContentPipeline\MathTypesTests.cs" /> <Compile Include="ContentPipeline\MathTypesTests.cs" />
<Compile Include="ContentPipeline\Helper\Compiler.cs" /> <Compile Include="ContentPipeline\Helper\Compiler.cs" />
@ -59,7 +60,6 @@
<Compile Include="IntegrationTest.cs" /> <Compile Include="IntegrationTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" /> <Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Strukturen\BoundingBoxTest.cs" /> <Compile Include="Strukturen\BoundingBoxTest.cs" />
<Compile Include="Strukturen\BoundingFrustumTest.cs" />
<Compile Include="Strukturen\BoundingSphereTest.cs" /> <Compile Include="Strukturen\BoundingSphereTest.cs" />
<Compile Include="Strukturen\ColorTest.cs" /> <Compile Include="Strukturen\ColorTest.cs" />
<Compile Include="Strukturen\MatrixTest.cs" /> <Compile Include="Strukturen\MatrixTest.cs" />

207
ANX.Framework.TestCenter/AssertHelper.cs Normal file
View File

@ -0,0 +1,207 @@
#region Using Statements
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
#endregion // Using Statements
#region License
//
// This file is part of the ANX.Framework created by the "ANX.Framework developer group".
//
// This file is released under the Ms-PL license.
//
//
//
// Microsoft Public License (Ms-PL)
//
// This license governs use of the accompanying software. If you use the software, you accept this license.
// If you do not accept the license, do not use the software.
//
// 1.Definitions
// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning
// here as under U.S. copyright law.
// A "contribution" is the original software, or any additions or changes to the software.
// A "contributor" is any person that distributes its contribution under this license.
// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
//
// 2.Grant of Rights
// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations
// in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to
// reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution
// or any derivative works that you create.
// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in
// section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed
// patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution
// in the software or derivative works of the contribution in the software.
//
// 3.Conditions and Limitations
// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your
// patent license from such contributor to the software ends automatically.
// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution
// notices that are present in the software.
// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including
// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or
// object code form, you may only do so under a license that complies with this license.
// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees,
// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the
// extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a
// particular purpose and non-infringement.
#endregion // License
using XNAColor = Microsoft.Xna.Framework.Color;
using ANXColor = ANX.Framework.Color;
using XNAVector2 = Microsoft.Xna.Framework.Vector2;
using ANXVector2 = ANX.Framework.Vector2;
using XNAVector3 = Microsoft.Xna.Framework.Vector3;
using ANXVector3 = ANX.Framework.Vector3;
using XNAVector4 = Microsoft.Xna.Framework.Vector4;
using ANXVector4 = ANX.Framework.Vector4;
using XNABoundingBox = Microsoft.Xna.Framework.BoundingBox;
using ANXBoundingBox = ANX.Framework.BoundingBox;
using XNABoundingSphere = Microsoft.Xna.Framework.BoundingSphere;
using ANXBoundingSphere = ANX.Framework.BoundingSphere;
using XNARect = Microsoft.Xna.Framework.Rectangle;
using ANXRect = ANX.Framework.Rectangle;
namespace ANX.Framework.TestCenter
{
class AssertHelper
{
public static void ConvertEquals(byte a, byte b, String test)
{
if (a == b)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: byte a: ({1}) byte b: ({2})", test, a, b));
}
}
public static void ConvertEquals(XNAColor xna, ANXColor anx, String test)
{
if (xna.R == anx.R &&
xna.G == anx.G &&
xna.B == anx.B &&
xna.A == anx.A)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
public static void ConvertEquals(XNAVector2 xna, ANXVector2 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (xna.X.ToString().Equals(anx.X.ToString()) && xna.Y.ToString().Equals(anx.Y.ToString()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}) anx({" + anx.X + "}{" + anx.Y + "})");
}
}
public static void ConvertEquals(ANXVector2 xna, ANXVector2 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (anx.X.ToString().Equals(anx.X.ToString()) && anx.Y.ToString().Equals(anx.Y.ToString()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: anx({" + xna.X + "}{" + xna.Y + "}) compared to anx({" + anx.X + "}{" + anx.Y + "})");
}
}
public static void ConvertEquals(XNAVector3 xna, ANXVector3 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1},{2},{3}) anx({4},{5},{6})", test, xna.X, xna.Y, xna.Z, anx.X, anx.Y, anx.Z));
}
}
public static void ConvertEquals(XNAVector4 xna, ANXVector4 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z) && (xna.W == anx.W))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1},{2},{3},{4}) anx({5},{6},{7},{8})", test, xna.X, xna.Y, xna.Z, xna.W, anx.X, anx.Y, anx.Z, anx.W));
}
}
public static void ConvertEquals(XNABoundingBox xna, ANXBoundingBox anx, String test)
{
if (xna.Min.X == anx.Min.X &&
xna.Min.Y == anx.Min.Y &&
xna.Min.Z == anx.Min.Z &&
xna.Max.X == anx.Max.X &&
xna.Max.Y == anx.Max.Y &&
xna.Max.Z == anx.Max.Z)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
public static void ConvertEquals(XNABoundingSphere xna, ANXBoundingSphere anx, String test)
{
if (xna.Center.X == anx.Center.X &&
xna.Center.Y == anx.Center.Y &&
xna.Center.Z == anx.Center.Z &&
xna.Radius == anx.Radius)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
public static void ConvertEquals(XNARect xna, ANXRect anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (xna.ToString().Equals(anx.ToString()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}{" + xna.Width + "}{" + xna.Height + "}) anx({" + anx.X + "}{" + anx.Y + "}{" + anx.Width + "}{" + anx.Height + "})");
}
}
}
}

8
ANX.Framework.TestCenter/DataFactory.cs
View File

@ -76,6 +76,14 @@ namespace ANX.Framework.TestCenter
return result; return result;
} }
public static float RandomNormalizedFloat
{
get
{
return 1.0f / MathHelper.Clamp(RandomFloat, 0f, float.MaxValue);
}
}
public static float RandomFloat public static float RandomFloat
{ {
get { return (float)(r.NextDouble() * (float.MaxValue - 1) - r.NextDouble() * (float.MinValue + 1)); } get { return (float)(r.NextDouble() * (float.MaxValue - 1) - r.NextDouble() * (float.MinValue + 1)); }

93
ANX.Framework.TestCenter/Strukturen/BoundingBoxTest.cs
View File

@ -65,79 +65,56 @@ namespace ANX.Framework.TestCenter.Strukturen
class BoundingBoxTest class BoundingBoxTest
{ {
#region Helper #region Helper
private static Random r = new Random();
public static float RandomFloat
{
get { return (float)(r.NextDouble()); }
}
static object[] sixfloat = static object[] sixfloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
static object[] ninefloat = static object[] ninefloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
static object[] tenfloat = static object[] tenfloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
static object[] twelvefloat = static object[] twelvefloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
static object[] twentytwofloat = static object[] twentytwofloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
private void ConvertEquals(XNABoundingBox xna, ANXBoundingBox anx, String test)
{
if (xna.Min.X == anx.Min.X &&
xna.Min.Y == anx.Min.Y &&
xna.Min.Z == anx.Min.Z &&
xna.Max.X == anx.Max.X &&
xna.Max.Y == anx.Max.Y &&
xna.Max.Z == anx.Max.Z)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
#endregion #endregion
#region Constructors #region Constructors
@ -148,7 +125,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingBox anx = new ANXBoundingBox(); ANXBoundingBox anx = new ANXBoundingBox();
ConvertEquals(xna, anx, "constructor0"); AssertHelper.ConvertEquals(xna, anx, "constructor0");
} }
[Test, TestCaseSource("sixfloat")] [Test, TestCaseSource("sixfloat")]
@ -158,7 +135,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingBox anx = new ANXBoundingBox(new ANXVector3(xMin, yMin, zMin), new ANXVector3(xMax, yMax, zMax)); ANXBoundingBox anx = new ANXBoundingBox(new ANXVector3(xMin, yMin, zMin), new ANXVector3(xMax, yMax, zMax));
ConvertEquals(xna, anx, "constructor0"); AssertHelper.ConvertEquals(xna, anx, "constructor0");
} }
#endregion #endregion
@ -259,7 +236,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateFromPoints(pointsXNA); XNABoundingBox xna = XNABoundingBox.CreateFromPoints(pointsXNA);
ANXBoundingBox anx = ANXBoundingBox.CreateFromPoints(pointsANX); ANXBoundingBox anx = ANXBoundingBox.CreateFromPoints(pointsANX);
ConvertEquals(xna, anx, "CreateFromPointsStatic"); AssertHelper.ConvertEquals(xna, anx, "CreateFromPointsStatic");
} }
[Test, TestCaseSource("ninefloat")] [Test, TestCaseSource("ninefloat")]
@ -276,7 +253,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateFromSphere(xnaSphere); XNABoundingBox xna = XNABoundingBox.CreateFromSphere(xnaSphere);
ANXBoundingBox anx = ANXBoundingBox.CreateFromSphere(anxSphere); ANXBoundingBox anx = ANXBoundingBox.CreateFromSphere(anxSphere);
ConvertEquals(xna, anx, "CreateFromSphereStatic"); AssertHelper.ConvertEquals(xna, anx, "CreateFromSphereStatic");
} }
[Test, TestCaseSource("twelvefloat")] [Test, TestCaseSource("twelvefloat")]
@ -293,7 +270,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateMerged(xnaBox1, xnaBox2); XNABoundingBox xna = XNABoundingBox.CreateMerged(xnaBox1, xnaBox2);
ANXBoundingBox anx = ANXBoundingBox.CreateMerged(anxBox1, anxBox2); ANXBoundingBox anx = ANXBoundingBox.CreateMerged(anxBox1, anxBox2);
ConvertEquals(xna, anx, "CreateMergedStatic"); AssertHelper.ConvertEquals(xna, anx, "CreateMergedStatic");
} }
[Test, TestCaseSource("sixfloat")] [Test, TestCaseSource("sixfloat")]

85
ANX.Framework.TestCenter/Strukturen/BoundingSphereTest.cs
View File

@ -65,68 +65,47 @@ namespace ANX.Framework.TestCenter.Strukturen
class BoundingSphereTest class BoundingSphereTest
{ {
#region Helper #region Helper
private static Random r = new Random();
public static float RandomFloat
{
get { return (float)(r.NextDouble()); }
}
static object[] fourfloat = static object[] fourfloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
static object[] eightfloat = static object[] eightfloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
static object[] tenfloat = static object[] tenfloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
static object[] twentyfloat = static object[] twentyfloat =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
}; };
private void ConvertEquals(XNABoundingSphere xna, ANXBoundingSphere anx, String test)
{
if (xna.Center.X == anx.Center.X &&
xna.Center.Y == anx.Center.Y &&
xna.Center.Z == anx.Center.Z &&
xna.Radius == anx.Radius)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
#endregion #endregion
#region Constructors #region Constructors
@ -137,7 +116,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingSphere anx = new ANXBoundingSphere(); ANXBoundingSphere anx = new ANXBoundingSphere();
ConvertEquals(xna, anx, "constructor0"); AssertHelper.ConvertEquals(xna, anx, "constructor0");
} }
[Test, TestCaseSource("fourfloat")] [Test, TestCaseSource("fourfloat")]
@ -147,7 +126,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingSphere anx = new ANXBoundingSphere(new ANXVector3(x, y, z), r); ANXBoundingSphere anx = new ANXBoundingSphere(new ANXVector3(x, y, z), r);
ConvertEquals(xna, anx, "constructor0"); AssertHelper.ConvertEquals(xna, anx, "constructor0");
} }
#endregion #endregion
@ -245,7 +224,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromBoundingBox(xnaBox); XNABoundingSphere xna = XNABoundingSphere.CreateFromBoundingBox(xnaBox);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromBoundingBox(anxBox); ANXBoundingSphere anx = ANXBoundingSphere.CreateFromBoundingBox(anxBox);
ConvertEquals(xna, anx, "CreateFromBoundingBox"); AssertHelper.ConvertEquals(xna, anx, "CreateFromBoundingBox");
} }
[Test, TestCaseSource("twentyfloat")] [Test, TestCaseSource("twentyfloat")]
@ -261,7 +240,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromFrustum(xnaFrustum); XNABoundingSphere xna = XNABoundingSphere.CreateFromFrustum(xnaFrustum);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromFrustum(anxFrustum); ANXBoundingSphere anx = ANXBoundingSphere.CreateFromFrustum(anxFrustum);
ConvertEquals(xna, anx, "CreateFromFrustumStatic"); AssertHelper.ConvertEquals(xna, anx, "CreateFromFrustumStatic");
} }
[Test, TestCaseSource("tenfloat")] [Test, TestCaseSource("tenfloat")]
@ -284,7 +263,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromPoints(pointsXNA); XNABoundingSphere xna = XNABoundingSphere.CreateFromPoints(pointsXNA);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromPoints(pointsANX); ANXBoundingSphere anx = ANXBoundingSphere.CreateFromPoints(pointsANX);
ConvertEquals(xna, anx, "CreateFromPointsStatic"); AssertHelper.ConvertEquals(xna, anx, "CreateFromPointsStatic");
} }
[Test, TestCaseSource("tenfloat")] [Test, TestCaseSource("tenfloat")]
@ -302,7 +281,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateMerged(xnaSphere1, xnaSphere2); XNABoundingSphere xna = XNABoundingSphere.CreateMerged(xnaSphere1, xnaSphere2);
ANXBoundingSphere anx = ANXBoundingSphere.CreateMerged(anxSphere1, anxSphere2); ANXBoundingSphere anx = ANXBoundingSphere.CreateMerged(anxSphere1, anxSphere2);
ConvertEquals(xna, anx, "CreateMergedStatic"); AssertHelper.ConvertEquals(xna, anx, "CreateMergedStatic");
} }
[Test, TestCaseSource("tenfloat")] [Test, TestCaseSource("tenfloat")]
@ -417,7 +396,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaSphere.Transform(xnaMatrix); xnaSphere.Transform(xnaMatrix);
anxSphere.Transform(anxMatrix); anxSphere.Transform(anxMatrix);
ConvertEquals(xnaSphere, anxSphere, "Transform"); AssertHelper.ConvertEquals(xnaSphere, anxSphere, "Transform");
} }
#endregion #endregion

150
ANX.Framework.TestCenter/Strukturen/ColorTest.cs
View File

@ -56,6 +56,9 @@ using System.Text;
using XNAColor = Microsoft.Xna.Framework.Color; using XNAColor = Microsoft.Xna.Framework.Color;
using ANXColor = ANX.Framework.Color; using ANXColor = ANX.Framework.Color;
using XNAVector3 = Microsoft.Xna.Framework.Vector3;
using ANXVector3 = ANX.Framework.Vector3;
using NUnit.Framework; using NUnit.Framework;
namespace ANX.Framework.TestCenter.Strukturen namespace ANX.Framework.TestCenter.Strukturen
@ -63,55 +66,33 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture] [TestFixture]
class ColorTest class ColorTest
{ {
private static Random r = new Random();
public static float RandomFloat
{
get { return (float)(r.NextDouble()); }
}
static object[] fourfloats = static object[] fourfloats =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat } new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat }
}; };
static object[] eightfloats = static object[] eightfloats =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat } new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
}; };
static object[] ninefloats = static object[] ninefloats =
{ {
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }, new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat } new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
}; };
private void ConvertEquals(XNAColor xna, ANXColor anx, String test)
{
if (xna.R == anx.R &&
xna.G == anx.G &&
xna.B == anx.B &&
xna.A == anx.A)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
#region Constructors #region Constructors
[Test] [Test]
public void constructor0() public void constructor0()
@ -119,7 +100,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(); XNAColor xna = new XNAColor();
ANXColor anx = new ANXColor(); ANXColor anx = new ANXColor();
ConvertEquals(xna, anx, "constructor0"); AssertHelper.ConvertEquals(xna, anx, "constructor0");
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -128,7 +109,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(new Microsoft.Xna.Framework.Vector3(r, g, b)); XNAColor xna = new XNAColor(new Microsoft.Xna.Framework.Vector3(r, g, b));
ANXColor anx = new ANXColor(new ANX.Framework.Vector3(r, g, b)); ANXColor anx = new ANXColor(new ANX.Framework.Vector3(r, g, b));
ConvertEquals(xna, anx, "constructor1"); AssertHelper.ConvertEquals(xna, anx, "constructor1");
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -137,7 +118,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(new Microsoft.Xna.Framework.Vector4(r, g, b, a)); XNAColor xna = new XNAColor(new Microsoft.Xna.Framework.Vector4(r, g, b, a));
ANXColor anx = new ANXColor(new ANX.Framework.Vector4(r, g, b, a)); ANXColor anx = new ANXColor(new ANX.Framework.Vector4(r, g, b, a));
ConvertEquals(xna, anx, "constructor2"); AssertHelper.ConvertEquals(xna, anx, "constructor2");
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -146,7 +127,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(r, g, b); XNAColor xna = new XNAColor(r, g, b);
ANXColor anx = new ANXColor(r, g, b); ANXColor anx = new ANXColor(r, g, b);
ConvertEquals(xna, anx, "constructor3"); AssertHelper.ConvertEquals(xna, anx, "constructor3");
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -155,7 +136,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor((int)(r * 255), (int)(g * 255), (int)(b * 255)); XNAColor xna = new XNAColor((int)(r * 255), (int)(g * 255), (int)(b * 255));
ANXColor anx = new ANXColor((int)(r * 255), (int)(g * 255), (int)(b * 255)); ANXColor anx = new ANXColor((int)(r * 255), (int)(g * 255), (int)(b * 255));
ConvertEquals(xna, anx, "constructor4"); AssertHelper.ConvertEquals(xna, anx, "constructor4");
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -164,7 +145,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(r, g, b) * a; XNAColor xna = new XNAColor(r, g, b) * a;
ANXColor anx = new ANXColor(r, g, b) * a; ANXColor anx = new ANXColor(r, g, b) * a;
ConvertEquals(xna, anx, "constructor5"); AssertHelper.ConvertEquals(xna, anx, "constructor5");
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -173,7 +154,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255)); XNAColor xna = new XNAColor((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
ANXColor anx = new ANXColor((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255)); ANXColor anx = new ANXColor((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
ConvertEquals(xna, anx, "constructor6"); AssertHelper.ConvertEquals(xna, anx, "constructor6");
} }
#endregion #endregion
@ -233,7 +214,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anx = ANXColor.FromNonPremultiplied((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255)); ANXColor anx = ANXColor.FromNonPremultiplied((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
ConvertEquals(xna, anx, "FromNonPremultipliedIntStatic"); AssertHelper.ConvertEquals(xna, anx, "FromNonPremultipliedIntStatic");
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -243,7 +224,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anx = ANXColor.FromNonPremultiplied(new ANX.Framework.Vector4(r, g, b, a)); ANXColor anx = ANXColor.FromNonPremultiplied(new ANX.Framework.Vector4(r, g, b, a));
ConvertEquals(xna, anx, "FromNonPremultipliedVector4Static"); AssertHelper.ConvertEquals(xna, anx, "FromNonPremultipliedVector4Static");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -251,6 +232,8 @@ namespace ANX.Framework.TestCenter.Strukturen
float r1, float g1, float b1, float a1, float r1, float g1, float b1, float a1,
float r2, float g2, float b2, float a2, float amount) float r2, float g2, float b2, float a2, float amount)
{ {
amount = MathHelper.Clamp(amount, 0, 1);
XNAColor xna1 = new XNAColor(r1, g1, b1) * a1; XNAColor xna1 = new XNAColor(r1, g1, b1) * a1;
XNAColor xna2 = new XNAColor(r2, g2, b2) * a2; XNAColor xna2 = new XNAColor(r2, g2, b2) * a2;
@ -260,7 +243,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = XNAColor.Lerp(xna1, xna2, amount); XNAColor xna = XNAColor.Lerp(xna1, xna2, amount);
ANXColor anx = ANXColor.Lerp(anx1, anx2, amount); ANXColor anx = ANXColor.Lerp(anx1, anx2, amount);
ConvertEquals(xna, anx, "LerpStatic"); AssertHelper.ConvertEquals(xna, anx, "LerpStatic");
} }
[Test, TestCaseSource("eightfloats")] [Test, TestCaseSource("eightfloats")]
@ -273,7 +256,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor.Multiply(xna, scale); XNAColor.Multiply(xna, scale);
ANXColor.Multiply(anx, scale); ANXColor.Multiply(anx, scale);
ConvertEquals(xna, anx, "MultiplyStatic"); AssertHelper.ConvertEquals(xna, anx, "MultiplyStatic");
} }
[Test, TestCaseSource("eightfloats")] [Test, TestCaseSource("eightfloats")]
@ -286,7 +269,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna *= scale; xna *= scale;
anx *= scale; anx *= scale;
ConvertEquals(xna, anx, "MultiplyOperator"); AssertHelper.ConvertEquals(xna, anx, "MultiplyOperator");
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -299,14 +282,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Microsoft.Xna.Framework.Vector3 xna = xnaColor.ToVector3(); Microsoft.Xna.Framework.Vector3 xna = xnaColor.ToVector3();
ANX.Framework.Vector3 anx = anxColor.ToVector3(); ANX.Framework.Vector3 anx = anxColor.ToVector3();
if (xna.Equals(anx)) AssertHelper.ConvertEquals(xna, anx, "ToVector3");
{
Assert.Pass("ToVector3 passed");
}
else
{
Assert.Fail(String.Format("ToVector3 failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -319,14 +295,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Microsoft.Xna.Framework.Vector4 xna = xnaColor.ToVector4(); Microsoft.Xna.Framework.Vector4 xna = xnaColor.ToVector4();
ANX.Framework.Vector4 anx = anxColor.ToVector4(); ANX.Framework.Vector4 anx = anxColor.ToVector4();
if (xna.Equals(anx)) AssertHelper.ConvertEquals(xna, anx, "ToVector4");
{
Assert.Pass("ToVector4 passed");
}
else
{
Assert.Fail(String.Format("ToVector4 failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
} }
#endregion // Methods #endregion // Methods
@ -360,17 +329,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a; ANXColor anxColor = new ANXColor(r, g, b) * a;
byte xna = xnaColor.R; AssertHelper.ConvertEquals(xnaColor.R, anxColor.R, "R");
byte anx = anxColor.R;
if (xna.Equals(anx))
{
Assert.Pass("R passed");
}
else
{
Assert.Fail(String.Format("R failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -380,17 +339,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a; ANXColor anxColor = new ANXColor(r, g, b) * a;
byte xna = xnaColor.G; AssertHelper.ConvertEquals(xnaColor.G, anxColor.G, "G");
byte anx = anxColor.G;
if (xna.Equals(anx))
{
Assert.Pass("G passed");
}
else
{
Assert.Fail(String.Format("G failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -400,17 +349,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a; ANXColor anxColor = new ANXColor(r, g, b) * a;
byte xna = xnaColor.B; AssertHelper.ConvertEquals(xnaColor.B, anxColor.B, "B");
byte anx = anxColor.B;
if (xna.Equals(anx))
{
Assert.Pass("B passed");
}
else
{
Assert.Fail(String.Format("B failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
} }
[Test, TestCaseSource("fourfloats")] [Test, TestCaseSource("fourfloats")]
@ -420,18 +359,9 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a; ANXColor anxColor = new ANXColor(r, g, b) * a;
byte xna = xnaColor.A; AssertHelper.ConvertEquals(xnaColor.A, anxColor.A, "A");
byte anx = anxColor.A;
if (xna.Equals(anx))
{
Assert.Pass("A passed");
}
else
{
Assert.Fail(String.Format("A failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
#endregion
} }
#endregion
} }
} }

27
ANX.Framework.TestCenter/Strukturen/MatrixTest.cs
View File

@ -94,30 +94,13 @@ namespace ANX.Framework.TestCenter.Strukturen
#endregion #endregion
#region Testdata #region Testdata
private static Random r = new Random();
public static float RandomFloat
{
get { return (float)(r.NextDouble() * (float.MaxValue - 1) - r.NextDouble() * (float.MinValue + 1)); }
}
public static int RandomBitPlus
{
get { return r.Next(3) - 1; }
}
public static float randomValue
{
get { return r.Next(1000) * RandomBitPlus; }
}
static object[] sixteenfloats = static object[] sixteenfloats =
{ {
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue }, new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue }, new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue }, new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue }, new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue }, new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
}; };
#endregion #endregion

29
ANX.Framework.TestCenter/Strukturen/RectangleTest.cs
View File

@ -63,23 +63,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture] [TestFixture]
class RectangleTest class RectangleTest
{ {
#region Helper
public void ConvertEquals(XNARect xna, ANXRect anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (xna.ToString().Equals(anx.ToString()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}{" + xna.Width + "}{" + xna.Height + "}) anx({" + anx.X + "}{" + anx.Y + "}{" + anx.Width + "}{" + anx.Height + "})");
}
}
#endregion
static object[] ninefloats = static object[] ninefloats =
{ {
@ -131,7 +114,7 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test] [Test]
public void Empty() public void Empty()
{ {
ConvertEquals(XNARect.Empty, ANXRect.Empty, "Empty"); AssertHelper.ConvertEquals(XNARect.Empty, ANXRect.Empty, "Empty");
} }
@ -209,7 +192,7 @@ namespace ANX.Framework.TestCenter.Strukturen
{ {
XNARect xna = new XNARect(x1, y1, w1, h1); XNARect xna = new XNARect(x1, y1, w1, h1);
ANXRect anx = new ANXRect(x1, y1, w1, h1); ANXRect anx = new ANXRect(x1, y1, w1, h1);
ConvertEquals(xna, anx, "Constructor"); AssertHelper.ConvertEquals(xna, anx, "Constructor");
} }
#endregion #endregion
@ -262,7 +245,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna.Inflate(x2, y2); xna.Inflate(x2, y2);
anx.Inflate(x2, y2); anx.Inflate(x2, y2);
ConvertEquals(xna, anx, "Inflate"); AssertHelper.ConvertEquals(xna, anx, "Inflate");
} }
[Test, TestCaseSource("ninefloats6")] [Test, TestCaseSource("ninefloats6")]
@ -285,7 +268,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna.Offset(x2, y2); xna.Offset(x2, y2);
anx.Offset(x2, y2); anx.Offset(x2, y2);
ConvertEquals(xna, anx, "Offset"); AssertHelper.ConvertEquals(xna, anx, "Offset");
} }
@ -298,7 +281,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNARect xna2 = new XNARect(x2, y2, w2, h2); XNARect xna2 = new XNARect(x2, y2, w2, h2);
ANXRect anx2 = new ANXRect(x2, y2, w2, h2); ANXRect anx2 = new ANXRect(x2, y2, w2, h2);
ConvertEquals(XNARect.Intersect(xna, xna2), ANXRect.Intersect(anx, anx2), "Intersection"); AssertHelper.ConvertEquals(XNARect.Intersect(xna, xna2), ANXRect.Intersect(anx, anx2), "Intersection");
} }
@ -310,7 +293,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNARect xna2 = new XNARect(x2, y2, w2, h2); XNARect xna2 = new XNARect(x2, y2, w2, h2);
ANXRect anx2 = new ANXRect(x2, y2, w2, h2); ANXRect anx2 = new ANXRect(x2, y2, w2, h2);
ConvertEquals(XNARect.Union(xna, xna2), ANXRect.Union(anx, anx2), "Union"); AssertHelper.ConvertEquals(XNARect.Union(xna, xna2), ANXRect.Union(anx, anx2), "Union");
} }

86
ANX.Framework.TestCenter/Strukturen/Vector2Test.cs
View File

@ -66,35 +66,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture] [TestFixture]
class Vector2Test class Vector2Test
{ {
#region Helper
public void ConvertEquals(XNAVector2 xna, ANXVector2 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (xna.X.ToString().Equals(anx.X.ToString()) && xna.Y.ToString().Equals(anx.Y.ToString()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}) anx({" + anx.X + "}{" + anx.Y + "})");
}
}
public void ConvertEquals(ANXVector2 xna, ANXVector2 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (anx.X.ToString().Equals(anx.X.ToString()) && anx.Y.ToString().Equals(anx.Y.ToString()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: anx({" + xna.X + "}{" + xna.Y + "}) compared to anx({" + anx.X + "}{" + anx.Y + "})");
}
}
#endregion
#region Testdata #region Testdata
static object[] ninefloats = static object[] ninefloats =
@ -121,27 +92,25 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test] [Test]
public void One() public void One()
{ {
AssertHelper.ConvertEquals(XNAVector2.One, ANXVector2.One, "One");
ConvertEquals(XNAVector2.One, ANXVector2.One, "One");
} }
[Test] [Test]
public void UnitX() public void UnitX()
{ {
ConvertEquals(XNAVector2.UnitX, ANXVector2.UnitX, "UnitX"); AssertHelper.ConvertEquals(XNAVector2.UnitX, ANXVector2.UnitX, "UnitX");
} }
[Test] [Test]
public void UnitY() public void UnitY()
{ {
ConvertEquals(XNAVector2.UnitY, ANXVector2.UnitY, "UnitY"); AssertHelper.ConvertEquals(XNAVector2.UnitY, ANXVector2.UnitY, "UnitY");
} }
[Test] [Test]
public void Zero() public void Zero()
{ {
ConvertEquals(XNAVector2.Zero, ANXVector2.Zero, "Zero"); AssertHelper.ConvertEquals(XNAVector2.Zero, ANXVector2.Zero, "Zero");
} }
#endregion #endregion
@ -155,8 +124,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxR = new ANXVector2(x); ANXVector2 anxR = new ANXVector2(x);
ConvertEquals(xnaR, anxR, "Constructor1"); AssertHelper.ConvertEquals(xnaR, anxR, "Constructor1");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -166,7 +134,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxR = new ANXVector2(x, y); ANXVector2 anxR = new ANXVector2(x, y);
ConvertEquals(xnaR, anxR, "Constructor2"); AssertHelper.ConvertEquals(xnaR, anxR, "Constructor2");
} }
#endregion #endregion
@ -185,7 +153,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Add(xna1, xna2); XNAVector2 xnaR = XNAVector2.Add(xna1, xna2);
ANXVector2 anxR = ANXVector2.Add(anx1, anx2); ANXVector2 anxR = ANXVector2.Add(anx1, anx2);
ConvertEquals(xnaR, anxR, "Add"); AssertHelper.ConvertEquals(xnaR, anxR, "Add");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -204,7 +172,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Barycentric(xna1, xna2, xna3, amount1, amount2); XNAVector2 xnaR = XNAVector2.Barycentric(xna1, xna2, xna3, amount1, amount2);
ANXVector2 anxR = ANXVector2.Barycentric(anx1, anx2, anx3, amount1, amount2); ANXVector2 anxR = ANXVector2.Barycentric(anx1, anx2, anx3, amount1, amount2);
ConvertEquals(xnaR, anxR, "Barycentric"); AssertHelper.ConvertEquals(xnaR, anxR, "Barycentric");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -223,7 +191,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.CatmullRom(xna1, xna2, xna3, xna4, amount); XNAVector2 xnaR = XNAVector2.CatmullRom(xna1, xna2, xna3, xna4, amount);
ANXVector2 anxR = ANXVector2.CatmullRom(anx1, anx2, anx3, anx4, amount); ANXVector2 anxR = ANXVector2.CatmullRom(anx1, anx2, anx3, anx4, amount);
ConvertEquals(xnaR, anxR, "CatmullRom"); AssertHelper.ConvertEquals(xnaR, anxR, "CatmullRom");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -242,7 +210,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Clamp(xna1, xna2, xna3); XNAVector2 xnaR = XNAVector2.Clamp(xna1, xna2, xna3);
ANXVector2 anxR = ANXVector2.Clamp(anx1, anx2, anx3); ANXVector2 anxR = ANXVector2.Clamp(anx1, anx2, anx3);
ConvertEquals(xnaR, anxR, "Clamp"); AssertHelper.ConvertEquals(xnaR, anxR, "Clamp");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -287,7 +255,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Divide(xna1, divider); XNAVector2 xnaR = XNAVector2.Divide(xna1, divider);
ANXVector2 anxR = ANXVector2.Divide(anx1, divider); ANXVector2 anxR = ANXVector2.Divide(anx1, divider);
ConvertEquals(xnaR, anxR, "DivideVectorDivider"); AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorDivider");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -302,7 +270,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Divide(xna1, xna2); XNAVector2 xnaR = XNAVector2.Divide(xna1, xna2);
ANXVector2 anxR = ANXVector2.Divide(anx1, anx2); ANXVector2 anxR = ANXVector2.Divide(anx1, anx2);
ConvertEquals(xnaR, anxR, "DivideVectorVector"); AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorVector");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -351,7 +319,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Hermite(xna1, xna2, xna3, xna4, amount); XNAVector2 xnaR = XNAVector2.Hermite(xna1, xna2, xna3, xna4, amount);
ANXVector2 anxR = ANXVector2.Hermite(anx1, anx2, anx3, anx4, amount); ANXVector2 anxR = ANXVector2.Hermite(anx1, anx2, anx3, anx4, amount);
ConvertEquals(xnaR, anxR, "Hermite"); AssertHelper.ConvertEquals(xnaR, anxR, "Hermite");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -382,7 +350,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Lerp(xna1, xna2, amount); XNAVector2 xnaR = XNAVector2.Lerp(xna1, xna2, amount);
ANXVector2 anxR = ANXVector2.Lerp(anx1, anx2, amount); ANXVector2 anxR = ANXVector2.Lerp(anx1, anx2, amount);
ConvertEquals(xnaR, anxR, "Lerp"); AssertHelper.ConvertEquals(xnaR, anxR, "Lerp");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -397,7 +365,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Max(xna1, xna2); XNAVector2 xnaR = XNAVector2.Max(xna1, xna2);
ANXVector2 anxR = ANXVector2.Max(anx1, anx2); ANXVector2 anxR = ANXVector2.Max(anx1, anx2);
ConvertEquals(xnaR, anxR, "Max"); AssertHelper.ConvertEquals(xnaR, anxR, "Max");
} }
@ -413,7 +381,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Min(xna1, xna2); XNAVector2 xnaR = XNAVector2.Min(xna1, xna2);
ANXVector2 anxR = ANXVector2.Min(anx1, anx2); ANXVector2 anxR = ANXVector2.Min(anx1, anx2);
ConvertEquals(xnaR, anxR, "Min"); AssertHelper.ConvertEquals(xnaR, anxR, "Min");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -426,7 +394,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Multiply(xna1, scale); XNAVector2 xnaR = XNAVector2.Multiply(xna1, scale);
ANXVector2 anxR = ANXVector2.Multiply(anx1, scale); ANXVector2 anxR = ANXVector2.Multiply(anx1, scale);
ConvertEquals(xnaR, anxR, "MultiplyVectorFloat"); AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -441,7 +409,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Multiply(xna1, xna2); XNAVector2 xnaR = XNAVector2.Multiply(xna1, xna2);
ANXVector2 anxR = ANXVector2.Multiply(anx1, anx2); ANXVector2 anxR = ANXVector2.Multiply(anx1, anx2);
ConvertEquals(xnaR, anxR, "MultiplyVectorVector"); AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -454,7 +422,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Negate(xna1); XNAVector2 xnaR = XNAVector2.Negate(xna1);
ANXVector2 anxR = ANXVector2.Negate(anx1); ANXVector2 anxR = ANXVector2.Negate(anx1);
ConvertEquals(xnaR, anxR, "Negate"); AssertHelper.ConvertEquals(xnaR, anxR, "Negate");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -467,7 +435,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaR.Normalize(); xnaR.Normalize();
anxR.Normalize(); anxR.Normalize();
ConvertEquals(xnaR, anxR, "NormalizeInstanz"); AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeInstanz");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -480,7 +448,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Normalize(xna1); XNAVector2 xnaR = XNAVector2.Normalize(xna1);
ANXVector2 anxR = ANXVector2.Normalize(anx1); ANXVector2 anxR = ANXVector2.Normalize(anx1);
ConvertEquals(xnaR, anxR, "NormalizeStatic"); AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeStatic");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -495,7 +463,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Reflect(xna1, xna2); XNAVector2 xnaR = XNAVector2.Reflect(xna1, xna2);
ANXVector2 anxR = ANXVector2.Reflect(anx1, anx2); ANXVector2 anxR = ANXVector2.Reflect(anx1, anx2);
ConvertEquals(xnaR, anxR, "Reflect"); AssertHelper.ConvertEquals(xnaR, anxR, "Reflect");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -510,7 +478,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.SmoothStep(xna1, xna2, amount); XNAVector2 xnaR = XNAVector2.SmoothStep(xna1, xna2, amount);
ANXVector2 anxR = ANXVector2.SmoothStep(anx1, anx2, amount); ANXVector2 anxR = ANXVector2.SmoothStep(anx1, anx2, amount);
ConvertEquals(xnaR, anxR, "SmoothStep"); AssertHelper.ConvertEquals(xnaR, anxR, "SmoothStep");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -525,7 +493,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Subtract(xna1, xna2); XNAVector2 xnaR = XNAVector2.Subtract(xna1, xna2);
ANXVector2 anxR = ANXVector2.Subtract(anx1, anx2); ANXVector2 anxR = ANXVector2.Subtract(anx1, anx2);
ConvertEquals(xnaR, anxR, "Subtract"); AssertHelper.ConvertEquals(xnaR, anxR, "Subtract");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -555,7 +523,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2.Transform(ref xna1, ref xnaMatrix, out xnaResult); XNAVector2.Transform(ref xna1, ref xnaMatrix, out xnaResult);
ANXVector2.Transform(ref anx1, ref anxMatrix, out anxResult); ANXVector2.Transform(ref anx1, ref anxMatrix, out anxResult);
ConvertEquals(xnaResult, anxResult, "StaticTransform"); AssertHelper.ConvertEquals(xnaResult, anxResult, "StaticTransform");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -569,7 +537,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXMatrix anxMatrix = ANXMatrix.CreateRotationX(nop1) * ANXMatrix.CreateRotationY(nop2) * ANXMatrix.CreateRotationZ(nop3) * ANXMatrix.CreateTranslation(nop4, nop5, nop1); ANXMatrix anxMatrix = ANXMatrix.CreateRotationX(nop1) * ANXMatrix.CreateRotationY(nop2) * ANXMatrix.CreateRotationZ(nop3) * ANXMatrix.CreateTranslation(nop4, nop5, nop1);
ANXVector2 anxResult = ANXVector2.Transform(anx1, anxMatrix); ANXVector2 anxResult = ANXVector2.Transform(anx1, anxMatrix);
ConvertEquals(xnaResult, anxResult, "StaticTransform2"); AssertHelper.ConvertEquals(xnaResult, anxResult, "StaticTransform2");
} }
[Test, TestCaseSource("ninefloats")] [Test, TestCaseSource("ninefloats")]
@ -583,7 +551,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Vector2.Transform(ref anx1, ref anxMatrix, out anxResult2); Vector2.Transform(ref anx1, ref anxMatrix, out anxResult2);
ConvertEquals(anxResult1, anxResult2, "StaticTransform3_ANXonly"); AssertHelper.ConvertEquals(anxResult1, anxResult2, "StaticTransform3_ANXonly");
} }
/* /*

85
ANX.Framework.TestCenter/Strukturen/Vector3Test.cs
View File

@ -66,23 +66,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture] [TestFixture]
class Vector3Test class Vector3Test
{ {
#region Helper
public void ConvertEquals(XNAVector3 xna, ANXVector3 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1}{2}{3}) anx({4}{5}{6})", test, xna.X, xna.Y, xna.Z, anx.X, anx.Y, anx.Z));
}
}
#endregion
#region Testdata #region Testdata
static object[] thirteenFloats = static object[] thirteenFloats =
@ -109,67 +92,67 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test] [Test]
public void One() public void One()
{ {
ConvertEquals(XNAVector3.One, ANXVector3.One, "One"); AssertHelper.ConvertEquals(XNAVector3.One, ANXVector3.One, "One");
} }
[Test] [Test]
public void Zero() public void Zero()
{ {
ConvertEquals(XNAVector3.Zero, ANXVector3.Zero, "Zero"); AssertHelper.ConvertEquals(XNAVector3.Zero, ANXVector3.Zero, "Zero");
} }
[Test] [Test]
public void Up() public void Up()
{ {
ConvertEquals(XNAVector3.Up, ANXVector3.Up, "Up"); AssertHelper.ConvertEquals(XNAVector3.Up, ANXVector3.Up, "Up");
} }
[Test] [Test]
public void Down() public void Down()
{ {
ConvertEquals(XNAVector3.Down, ANXVector3.Down, "Down"); AssertHelper.ConvertEquals(XNAVector3.Down, ANXVector3.Down, "Down");
} }
[Test] [Test]
public void Backward() public void Backward()
{ {
ConvertEquals(XNAVector3.Backward, ANXVector3.Backward, "Backward"); AssertHelper.ConvertEquals(XNAVector3.Backward, ANXVector3.Backward, "Backward");
} }
[Test] [Test]
public void Forward() public void Forward()
{ {
ConvertEquals(XNAVector3.Forward, ANXVector3.Forward, "Forward"); AssertHelper.ConvertEquals(XNAVector3.Forward, ANXVector3.Forward, "Forward");
} }
[Test] [Test]
public void Left() public void Left()
{ {
ConvertEquals(XNAVector3.Left, ANXVector3.Left, "Left"); AssertHelper.ConvertEquals(XNAVector3.Left, ANXVector3.Left, "Left");
} }
[Test] [Test]
public void Right() public void Right()
{ {
ConvertEquals(XNAVector3.Right, ANXVector3.Right, "Right"); AssertHelper.ConvertEquals(XNAVector3.Right, ANXVector3.Right, "Right");
} }
[Test] [Test]
public void UnitX() public void UnitX()
{ {
ConvertEquals(XNAVector3.UnitX, ANXVector3.UnitX, "UnitX"); AssertHelper.ConvertEquals(XNAVector3.UnitX, ANXVector3.UnitX, "UnitX");
} }
[Test] [Test]
public void UnitY() public void UnitY()
{ {
ConvertEquals(XNAVector3.UnitY, ANXVector3.UnitY, "UnitY"); AssertHelper.ConvertEquals(XNAVector3.UnitY, ANXVector3.UnitY, "UnitY");
} }
[Test] [Test]
public void UnitZ() public void UnitZ()
{ {
ConvertEquals(XNAVector3.UnitZ, ANXVector3.UnitZ, "UnitZ"); AssertHelper.ConvertEquals(XNAVector3.UnitZ, ANXVector3.UnitZ, "UnitZ");
} }
#endregion #endregion
@ -183,7 +166,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3(); ANXVector3 anxR = new ANXVector3();
ConvertEquals(xnaR, anxR, "Constructor1"); AssertHelper.ConvertEquals(xnaR, anxR, "Constructor1");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -193,7 +176,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3(x); ANXVector3 anxR = new ANXVector3(x);
ConvertEquals(xnaR, anxR, "Constructor2"); AssertHelper.ConvertEquals(xnaR, anxR, "Constructor2");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -205,7 +188,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxV2 = new ANXVector2(x, y); ANXVector2 anxV2 = new ANXVector2(x, y);
ANXVector3 anxR = new ANXVector3(anxV2, z); ANXVector3 anxR = new ANXVector3(anxV2, z);
ConvertEquals(xnaR, anxR, "Constructor3"); AssertHelper.ConvertEquals(xnaR, anxR, "Constructor3");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -215,7 +198,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3(x, y, z); ANXVector3 anxR = new ANXVector3(x, y, z);
ConvertEquals(xnaR, anxR, "Constructor4"); AssertHelper.ConvertEquals(xnaR, anxR, "Constructor4");
} }
#endregion #endregion
@ -234,7 +217,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Add(xna1, xna2); XNAVector3 xnaR = XNAVector3.Add(xna1, xna2);
ANXVector3 anxR = ANXVector3.Add(anx1, anx2); ANXVector3 anxR = ANXVector3.Add(anx1, anx2);
ConvertEquals(xnaR, anxR, "Add"); AssertHelper.ConvertEquals(xnaR, anxR, "Add");
} }
@ -254,7 +237,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Barycentric(xna1, xna2, xna3, amount1, amount2); XNAVector3 xnaR = XNAVector3.Barycentric(xna1, xna2, xna3, amount1, amount2);
ANXVector3 anxR = ANXVector3.Barycentric(anx1, anx2, anx3, amount1, amount2); ANXVector3 anxR = ANXVector3.Barycentric(anx1, anx2, anx3, amount1, amount2);
ConvertEquals(xnaR, anxR, "Barycentric"); AssertHelper.ConvertEquals(xnaR, anxR, "Barycentric");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -273,7 +256,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.CatmullRom(xna1, xna2, xna3, xna4, amount); XNAVector3 xnaR = XNAVector3.CatmullRom(xna1, xna2, xna3, xna4, amount);
ANXVector3 anxR = ANXVector3.CatmullRom(anx1, anx2, anx3, anx4, amount); ANXVector3 anxR = ANXVector3.CatmullRom(anx1, anx2, anx3, anx4, amount);
ConvertEquals(xnaR, anxR, "CatmullRom"); AssertHelper.ConvertEquals(xnaR, anxR, "CatmullRom");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -290,7 +273,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Clamp(xna1, xna2, xna3); XNAVector3 xnaR = XNAVector3.Clamp(xna1, xna2, xna3);
ANXVector3 anxR = ANXVector3.Clamp(anx1, anx2, anx3); ANXVector3 anxR = ANXVector3.Clamp(anx1, anx2, anx3);
ConvertEquals(xnaR, anxR, "Clamp"); AssertHelper.ConvertEquals(xnaR, anxR, "Clamp");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -305,7 +288,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Cross(xna1, xna2); XNAVector3 xnaR = XNAVector3.Cross(xna1, xna2);
ANXVector3 anxR = ANXVector3.Cross(anx2, anx2); ANXVector3 anxR = ANXVector3.Cross(anx2, anx2);
ConvertEquals(xnaR, anxR, "Cross"); AssertHelper.ConvertEquals(xnaR, anxR, "Cross");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -348,7 +331,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Divide(xna1, divider); XNAVector3 xnaR = XNAVector3.Divide(xna1, divider);
ANXVector3 anxR = ANXVector3.Divide(anx1, divider); ANXVector3 anxR = ANXVector3.Divide(anx1, divider);
ConvertEquals(xnaR, anxR, "DivideVectorDivider"); AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorDivider");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -363,7 +346,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Divide(xna1, xna2); XNAVector3 xnaR = XNAVector3.Divide(xna1, xna2);
ANXVector3 anxR = ANXVector3.Divide(anx1, anx2); ANXVector3 anxR = ANXVector3.Divide(anx1, anx2);
ConvertEquals(xnaR, anxR, "DivideVectorVector"); AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorVector");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -411,7 +394,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Hermite(xna1, xna2, xna3, xna4, amount); XNAVector3 xnaR = XNAVector3.Hermite(xna1, xna2, xna3, xna4, amount);
ANXVector3 anxR = ANXVector3.Hermite(anx1, anx2, anx3, anx4, amount); ANXVector3 anxR = ANXVector3.Hermite(anx1, anx2, anx3, anx4, amount);
ConvertEquals(xnaR, anxR, "Hermite"); AssertHelper.ConvertEquals(xnaR, anxR, "Hermite");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -442,7 +425,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Lerp(xna1, xna2, amount); XNAVector3 xnaR = XNAVector3.Lerp(xna1, xna2, amount);
ANXVector3 anxR = ANXVector3.Lerp(anx1, anx2, amount); ANXVector3 anxR = ANXVector3.Lerp(anx1, anx2, amount);
ConvertEquals(xnaR, anxR, "Lerp"); AssertHelper.ConvertEquals(xnaR, anxR, "Lerp");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -457,7 +440,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Max(xna1, xna2); XNAVector3 xnaR = XNAVector3.Max(xna1, xna2);
ANXVector3 anxR = ANXVector3.Max(anx1, anx2); ANXVector3 anxR = ANXVector3.Max(anx1, anx2);
ConvertEquals(xnaR, anxR, "Max"); AssertHelper.ConvertEquals(xnaR, anxR, "Max");
} }
@ -473,7 +456,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Min(xna1, xna2); XNAVector3 xnaR = XNAVector3.Min(xna1, xna2);
ANXVector3 anxR = ANXVector3.Min(anx1, anx2); ANXVector3 anxR = ANXVector3.Min(anx1, anx2);
ConvertEquals(xnaR, anxR, "Min"); AssertHelper.ConvertEquals(xnaR, anxR, "Min");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -488,7 +471,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Multiply(xna1, scale); XNAVector3 xnaR = XNAVector3.Multiply(xna1, scale);
ANXVector3 anxR = ANXVector3.Multiply(anx1, scale); ANXVector3 anxR = ANXVector3.Multiply(anx1, scale);
ConvertEquals(xnaR, anxR, "MultiplyVectorFloat"); AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -503,7 +486,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Multiply(xna1, xna2); XNAVector3 xnaR = XNAVector3.Multiply(xna1, xna2);
ANXVector3 anxR = ANXVector3.Multiply(anx1, anx2); ANXVector3 anxR = ANXVector3.Multiply(anx1, anx2);
ConvertEquals(xnaR, anxR, "MultiplyVectorVector"); AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -516,7 +499,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Negate(xna1); XNAVector3 xnaR = XNAVector3.Negate(xna1);
ANXVector3 anxR = ANXVector3.Negate(anx1); ANXVector3 anxR = ANXVector3.Negate(anx1);
ConvertEquals(xnaR, anxR, "Negate"); AssertHelper.ConvertEquals(xnaR, anxR, "Negate");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -529,7 +512,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaR.Normalize(); xnaR.Normalize();
anxR.Normalize(); anxR.Normalize();
ConvertEquals(xnaR, anxR, "NormalizeInstanz"); AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeInstanz");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -542,7 +525,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Normalize(xna1); XNAVector3 xnaR = XNAVector3.Normalize(xna1);
ANXVector3 anxR = ANXVector3.Normalize(anx1); ANXVector3 anxR = ANXVector3.Normalize(anx1);
ConvertEquals(xnaR, anxR, "NormalizeStatic"); AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeStatic");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -557,7 +540,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Reflect(xna1, xna2); XNAVector3 xnaR = XNAVector3.Reflect(xna1, xna2);
ANXVector3 anxR = ANXVector3.Reflect(anx1, anx2); ANXVector3 anxR = ANXVector3.Reflect(anx1, anx2);
ConvertEquals(xnaR, anxR, "Reflect"); AssertHelper.ConvertEquals(xnaR, anxR, "Reflect");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -572,7 +555,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.SmoothStep(xna1, xna2, amount); XNAVector3 xnaR = XNAVector3.SmoothStep(xna1, xna2, amount);
ANXVector3 anxR = ANXVector3.SmoothStep(anx1, anx2, amount); ANXVector3 anxR = ANXVector3.SmoothStep(anx1, anx2, amount);
ConvertEquals(xnaR, anxR, "SmoothStep"); AssertHelper.ConvertEquals(xnaR, anxR, "SmoothStep");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]
@ -587,7 +570,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Subtract(xna1, xna2); XNAVector3 xnaR = XNAVector3.Subtract(xna1, xna2);
ANXVector3 anxR = ANXVector3.Subtract(anx1, anx2); ANXVector3 anxR = ANXVector3.Subtract(anx1, anx2);
ConvertEquals(xnaR, anxR, "Subtract"); AssertHelper.ConvertEquals(xnaR, anxR, "Subtract");
} }
[Test, TestCaseSource("thirteenFloats")] [Test, TestCaseSource("thirteenFloats")]

31
ANX.Framework.TestCenter/Strukturen/Vector4Test.cs
View File

@ -87,14 +87,17 @@ namespace ANX.Framework.TestCenter.Strukturen
#region Testdata #region Testdata
static object[] fourFloats =
{
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
};
static object[] seventeenFloats = static object[] seventeenFloats =
{ {
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat },
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat },
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue}, new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue}, new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue}, new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
@ -158,8 +161,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor1"); ConvertEquals(xnaR, anxR, "Constructor1");
} }
[Test, TestCaseSource("seventeenFloats")] [Test, TestCaseSource("fourFloats")]
public void constructor2(float x, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12) public void constructor2(float x, float nop1, float nop2, float nop3)
{ {
XNAVector4 xnaR = new XNAVector4(x); XNAVector4 xnaR = new XNAVector4(x);
@ -168,8 +171,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor2"); ConvertEquals(xnaR, anxR, "Constructor2");
} }
[Test, TestCaseSource("seventeenFloats")] [Test, TestCaseSource("fourFloats")]
public void constructor3(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9) public void constructor3(float x, float y, float z, float w)
{ {
XNAVector3 xnaV3 = new XNAVector3(x, y, z); XNAVector3 xnaV3 = new XNAVector3(x, y, z);
XNAVector4 xnaR = new XNAVector4(xnaV3, w); XNAVector4 xnaR = new XNAVector4(xnaV3, w);
@ -180,8 +183,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor3"); ConvertEquals(xnaR, anxR, "Constructor3");
} }
[Test, TestCaseSource("seventeenFloats")] [Test, TestCaseSource("fourFloats")]
public void constructor4(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9) public void constructor4(float x, float y, float z, float w)
{ {
XNAVector2 xnaV2 = new XNAVector2(x, y); XNAVector2 xnaV2 = new XNAVector2(x, y);
XNAVector4 xnaR = new XNAVector4(xnaV2, z, w); XNAVector4 xnaR = new XNAVector4(xnaV2, z, w);
@ -192,8 +195,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor4"); ConvertEquals(xnaR, anxR, "Constructor4");
} }
[Test, TestCaseSource("seventeenFloats")] [Test, TestCaseSource("fourFloats")]
public void constructor5(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9) public void constructor5(float x, float y, float z, float w)
{ {
XNAVector4 xnaR = new XNAVector4(x, y, z, w); XNAVector4 xnaR = new XNAVector4(x, y, z, w);

91
ANX.Framework/Color.cs
View File

@ -865,12 +865,32 @@ namespace ANX.Framework
public static Color FromNonPremultiplied(int r, int g, int b, int a) public static Color FromNonPremultiplied(int r, int g, int b, int a)
{ {
throw new NotImplementedException(); Color color;
r = r * a;
g = g * a;
b = b * a;
if (((((r | g) | b) | a) & -256) != 0)
{
r = r < 0 ? 0 : (r > 255 ? 255 : r);
g = g < 0 ? 0 : (g > 255 ? 255 : g);
b = b < 0 ? 0 : (b > 255 ? 255 : b);
a = a < 0 ? 0 : (a > 255 ? 255 : a);
}
color.packedValue = (uint)(((r | g << 8) | b << 16) | a << 24);
return color;
} }
public static Color FromNonPremultiplied(Vector4 vector) public static Color FromNonPremultiplied(Vector4 vector)
{ {
throw new NotImplementedException(); Color color;
color.packedValue = ColorPack(vector.X * vector.W, vector.Y * vector.W, vector.Z * vector.W, vector.W);
return color;
} }
public override int GetHashCode() public override int GetHashCode()
@ -880,12 +900,54 @@ namespace ANX.Framework
public static Color Lerp(Color value1, Color value2, float amount) public static Color Lerp(Color value1, Color value2, float amount)
{ {
throw new NotImplementedException(); Color color;
byte r1 = (byte)value1.packedValue;
byte g1 = (byte)(value1.packedValue >> 8);
byte b1 = (byte)(value1.packedValue >> 16);
byte a1 = (byte)(value1.packedValue >> 24);
byte r2 = (byte)value2.packedValue;
byte g2 = (byte)(value2.packedValue >> 8);
byte b2 = (byte)(value2.packedValue >> 16);
byte a2 = (byte)(value2.packedValue >> 24);
int factor = (int)PackUNormal(65536f, amount);
int r3 = r1 + (((r2 - r1) * factor) >> 16);
int g3 = g1 + (((g2 - g1) * factor) >> 16);
int b3 = b1 + (((b2 - b1) * factor) >> 16);
int a3 = a1 + (((a2 - a1) * factor) >> 16);
color.packedValue = (uint)(((r3 | (g3 << 8)) | (b3 << 16)) | (a3 << 24));
return color;
} }
public static Color Multiply(Color value, float scale) public static Color Multiply(Color value, float scale)
{ {
throw new NotImplementedException(); Color color;
uint r = (byte)value.packedValue;
uint g = (byte)(value.packedValue >> 8);
uint b = (byte)(value.packedValue >> 16);
uint a = (byte)(value.packedValue >> 24);
uint uintScale = (uint)MathHelper.Clamp(scale * 65536f, 0, 0xffffff);
r = (r * uintScale) >> 16;
g = (g * uintScale) >> 16;
b = (b * uintScale) >> 16;
a = (a * uintScale) >> 16;
r = r > 255 ? 255 : r;
g = g > 255 ? 255 : g;
b = b > 255 ? 255 : b;
a = a > 255 ? 255 : a;
color.packedValue = ((r | (g << 8)) | (b << 0x10)) | (a << 0x18);
return color;
} }
public static Color operator *(Color a, float scale) public static Color operator *(Color a, float scale)
@ -900,12 +962,29 @@ namespace ANX.Framework
public Vector3 ToVector3() public Vector3 ToVector3()
{ {
return new Vector3(R, G, B); Vector3 result;
result.X = (packedValue & 255);
result.Y = (packedValue >> 8 & 255);
result.Z = (packedValue >> 16 & 255);
result /= 0xff;
return result;
} }
public Vector4 ToVector4() public Vector4 ToVector4()
{ {
return new Vector4(R, G, B, A); Vector4 result;
result.X = (packedValue & 255);
result.Y = (packedValue >> 8 & 255);
result.Z = (packedValue >> 16 & 255);
result.W = (packedValue >> 24 & 255);
result /= 0xff;
return result;
} }
public void PackFromVector4(Vector4 vector) public void PackFromVector4(Vector4 vector)

2
ANX.Framework/Vector3.cs
View File

@ -264,7 +264,7 @@ namespace ANX.Framework
public static void Divide(ref Vector3 value1, float value2, out Vector3 result) public static void Divide(ref Vector3 value1, float value2, out Vector3 result)
{ {
float divFactor = 1 / value2; float divFactor = 1f / value2;
Multiply(ref value1, divFactor, out result); Multiply(ref value1, divFactor, out result);
} }